Line Hotness Optimization Source Inline Context
1
/*
2
3
Unicode implementation based on original code by Fredrik Lundh,
4
modified by Marc-Andre Lemburg <mal@lemburg.com>.
5
6
Major speed upgrades to the method implementations at the Reykjavik
7
NeedForSpeed sprint, by Fredrik Lundh and Andrew Dalke.
8
9
Copyright (c) Corporation for National Research Initiatives.
10
11
--------------------------------------------------------------------
12
The original string type implementation is:
13
14
  Copyright (c) 1999 by Secret Labs AB
15
  Copyright (c) 1999 by Fredrik Lundh
16
17
By obtaining, using, and/or copying this software and/or its
18
associated documentation, you agree that you have read, understood,
19
and will comply with the following terms and conditions:
20
21
Permission to use, copy, modify, and distribute this software and its
22
associated documentation for any purpose and without fee is hereby
23
granted, provided that the above copyright notice appears in all
24
copies, and that both that copyright notice and this permission notice
25
appear in supporting documentation, and that the name of Secret Labs
26
AB or the author not be used in advertising or publicity pertaining to
27
distribution of the software without specific, written prior
28
permission.
29
30
SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
31
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
32
FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR
33
ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
34
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
35
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
36
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
37
--------------------------------------------------------------------
38
39
*/
40
41
#define PY_SSIZE_T_CLEAN
42
#include "Python.h"
43
#include "ucnhash.h"
44
#include "bytes_methods.h"
45
#include "stringlib/eq.h"
46
47
#ifdef MS_WINDOWS
48
#include <windows.h>
49
#endif
50
51
/*[clinic input]
52
class str "PyUnicodeObject *" "&PyUnicode_Type"
53
[clinic start generated code]*/
54
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=604e916854800fa8]*/
55
56
/* --- Globals ------------------------------------------------------------
57
58
NOTE: In the interpreter's initialization phase, some globals are currently
59
      initialized dynamically as needed. In the process Unicode objects may
60
      be created before the Unicode type is ready.
61
62
*/
63
64
65
#ifdef __cplusplus
66
extern "C" {
67
#endif
68
69
/* Maximum code point of Unicode 6.0: 0x10ffff (1,114,111) */
70
#define MAX_UNICODE 0x10ffff
71
72
#ifdef Py_DEBUG
73
#  define _PyUnicode_CHECK(op) _PyUnicode_CheckConsistency(op, 0)
74
#else
75
#  define _PyUnicode_CHECK(op) PyUnicode_Check(op)
76
#endif
77
78
#define _PyUnicode_UTF8(op)                             \
79
    (((PyCompactUnicodeObject*)(op))->utf8)
80
#define PyUnicode_UTF8(op)                              \
81
    (assert(_PyUnicode_CHECK(op)),                      \
82
     assert(PyUnicode_IS_READY(op)),                    \
83
     PyUnicode_IS_COMPACT_ASCII(op) ?                   \
84
         ((char*)((PyASCIIObject*)(op) + 1)) :          \
85
         _PyUnicode_UTF8(op))
86
#define _PyUnicode_UTF8_LENGTH(op)                      \
87
    (((PyCompactUnicodeObject*)(op))->utf8_length)
88
#define PyUnicode_UTF8_LENGTH(op)                       \
89
    (assert(_PyUnicode_CHECK(op)),                      \
90
     assert(PyUnicode_IS_READY(op)),                    \
91
     PyUnicode_IS_COMPACT_ASCII(op) ?                   \
92
         ((PyASCIIObject*)(op))->length :               \
93
         _PyUnicode_UTF8_LENGTH(op))
94
#define _PyUnicode_WSTR(op)                             \
95
    (((PyASCIIObject*)(op))->wstr)
96
#define _PyUnicode_WSTR_LENGTH(op)                      \
97
    (((PyCompactUnicodeObject*)(op))->wstr_length)
98
#define _PyUnicode_LENGTH(op)                           \
99
    (((PyASCIIObject *)(op))->length)
100
#define _PyUnicode_STATE(op)                            \
101
    (((PyASCIIObject *)(op))->state)
102
#define _PyUnicode_HASH(op)                             \
103
    (((PyASCIIObject *)(op))->hash)
104
#define _PyUnicode_KIND(op)                             \
105
    (assert(_PyUnicode_CHECK(op)),                      \
106
     ((PyASCIIObject *)(op))->state.kind)
107
#define _PyUnicode_GET_LENGTH(op)                       \
108
    (assert(_PyUnicode_CHECK(op)),                      \
109
     ((PyASCIIObject *)(op))->length)
110
#define _PyUnicode_DATA_ANY(op)                         \
111
    (((PyUnicodeObject*)(op))->data.any)
112
113
#undef PyUnicode_READY
114
#define PyUnicode_READY(op)                             \
115
    (assert(_PyUnicode_CHECK(op)),                      \
116
     (PyUnicode_IS_READY(op) ?                          \
117
      0 :                                               \
118
      _PyUnicode_Ready(op)))
119
120
#define _PyUnicode_SHARE_UTF8(op)                       \
121
    (assert(_PyUnicode_CHECK(op)),                      \
122
     assert(!PyUnicode_IS_COMPACT_ASCII(op)),           \
123
     (_PyUnicode_UTF8(op) == PyUnicode_DATA(op)))
124
#define _PyUnicode_SHARE_WSTR(op)                       \
125
    (assert(_PyUnicode_CHECK(op)),                      \
126
     (_PyUnicode_WSTR(unicode) == PyUnicode_DATA(op)))
127
128
/* true if the Unicode object has an allocated UTF-8 memory block
129
   (not shared with other data) */
130
#define _PyUnicode_HAS_UTF8_MEMORY(op)                  \
131
    ((!PyUnicode_IS_COMPACT_ASCII(op)                   \
132
      && _PyUnicode_UTF8(op)                            \
133
      && _PyUnicode_UTF8(op) != PyUnicode_DATA(op)))
134
135
/* true if the Unicode object has an allocated wstr memory block
136
   (not shared with other data) */
137
#define _PyUnicode_HAS_WSTR_MEMORY(op)                  \
138
    ((_PyUnicode_WSTR(op) &&                            \
139
      (!PyUnicode_IS_READY(op) ||                       \
140
       _PyUnicode_WSTR(op) != PyUnicode_DATA(op))))
141
142
/* Generic helper macro to convert characters of different types.
143
   from_type and to_type have to be valid type names, begin and end
144
   are pointers to the source characters which should be of type
145
   "from_type *".  to is a pointer of type "to_type *" and points to the
146
   buffer where the result characters are written to. */
147
#define _PyUnicode_CONVERT_BYTES(from_type, to_type, begin, end, to) \
148
    do {                                                \
149
        to_type *_to = (to_type *)(to);                \
150
        const from_type *_iter = (from_type *)(begin);  \
151
        const from_type *_end = (from_type *)(end);     \
152
        Py_ssize_t n = (_end) - (_iter);                \
153
        const from_type *_unrolled_end =                \
154
            _iter + _Py_SIZE_ROUND_DOWN(n, 4);          \
155
        while (_iter < (_unrolled_end)) {               \
156
            _to[0] = (to_type) _iter[0];                \
157
            _to[1] = (to_type) _iter[1];                \
158
            _to[2] = (to_type) _iter[2];                \
159
            _to[3] = (to_type) _iter[3];                \
160
            _iter += 4; _to += 4;                       \
161
        }                                               \
162
        while (_iter < (_end))                          \
163
            *_to++ = (to_type) *_iter++;                \
164
    } while (0)
165
166
#ifdef MS_WINDOWS
167
   /* On Windows, overallocate by 50% is the best factor */
168
#  define OVERALLOCATE_FACTOR 2
169
#else
170
   /* On Linux, overallocate by 25% is the best factor */
171
#  define OVERALLOCATE_FACTOR 4
172
#endif
173
174
/* This dictionary holds all interned unicode strings.  Note that references
175
   to strings in this dictionary are *not* counted in the string's ob_refcnt.
176
   When the interned string reaches a refcnt of 0 the string deallocation
177
   function will delete the reference from this dictionary.
178
179
   Another way to look at this is that to say that the actual reference
180
   count of a string is:  s->ob_refcnt + (s->state ? 2 : 0)
181
*/
182
static PyObject *interned = NULL;
183
184
/* The empty Unicode object is shared to improve performance. */
185
static PyObject *unicode_empty = NULL;
186
187
#define _Py_INCREF_UNICODE_EMPTY()                      \
188
    do {                                                \
189
        if (unicode_empty != NULL)                      \
190
            Py_INCREF(unicode_empty);                   \
191
        else {                                          \
192
            unicode_empty = PyUnicode_New(0, 0);        \
193
            if (unicode_empty != NULL) {                \
194
                Py_INCREF(unicode_empty);               \
195
                assert(_PyUnicode_CheckConsistency(unicode_empty, 1)); \
196
            }                                           \
197
        }                                               \
198
    } while (0)
199
200
#define _Py_RETURN_UNICODE_EMPTY()                      \
201
    do {                                                \
202
        _Py_INCREF_UNICODE_EMPTY();                     \
203
        return unicode_empty;                           \
204
    } while (0)
205
206
/* Forward declaration */
207
static inline int
208
_PyUnicodeWriter_WriteCharInline(_PyUnicodeWriter *writer, Py_UCS4 ch);
209
210
/* List of static strings. */
211
static _Py_Identifier *static_strings = NULL;
212
213
/* Single character Unicode strings in the Latin-1 range are being
214
   shared as well. */
215
static PyObject *unicode_latin1[256] = {NULL};
216
217
/* Fast detection of the most frequent whitespace characters */
218
const unsigned char _Py_ascii_whitespace[] = {
219
    0, 0, 0, 0, 0, 0, 0, 0,
220
/*     case 0x0009: * CHARACTER TABULATION */
221
/*     case 0x000A: * LINE FEED */
222
/*     case 0x000B: * LINE TABULATION */
223
/*     case 0x000C: * FORM FEED */
224
/*     case 0x000D: * CARRIAGE RETURN */
225
    0, 1, 1, 1, 1, 1, 0, 0,
226
    0, 0, 0, 0, 0, 0, 0, 0,
227
/*     case 0x001C: * FILE SEPARATOR */
228
/*     case 0x001D: * GROUP SEPARATOR */
229
/*     case 0x001E: * RECORD SEPARATOR */
230
/*     case 0x001F: * UNIT SEPARATOR */
231
    0, 0, 0, 0, 1, 1, 1, 1,
232
/*     case 0x0020: * SPACE */
233
    1, 0, 0, 0, 0, 0, 0, 0,
234
    0, 0, 0, 0, 0, 0, 0, 0,
235
    0, 0, 0, 0, 0, 0, 0, 0,
236
    0, 0, 0, 0, 0, 0, 0, 0,
237
238
    0, 0, 0, 0, 0, 0, 0, 0,
239
    0, 0, 0, 0, 0, 0, 0, 0,
240
    0, 0, 0, 0, 0, 0, 0, 0,
241
    0, 0, 0, 0, 0, 0, 0, 0,
242
    0, 0, 0, 0, 0, 0, 0, 0,
243
    0, 0, 0, 0, 0, 0, 0, 0,
244
    0, 0, 0, 0, 0, 0, 0, 0,
245
    0, 0, 0, 0, 0, 0, 0, 0
246
};
247
248
/* forward */
249
static PyUnicodeObject *_PyUnicode_New(Py_ssize_t length);
250
static PyObject* get_latin1_char(unsigned char ch);
251
static int unicode_modifiable(PyObject *unicode);
252
253
254
static PyObject *
255
_PyUnicode_FromUCS1(const Py_UCS1 *s, Py_ssize_t size);
256
static PyObject *
257
_PyUnicode_FromUCS2(const Py_UCS2 *s, Py_ssize_t size);
258
static PyObject *
259
_PyUnicode_FromUCS4(const Py_UCS4 *s, Py_ssize_t size);
260
261
static PyObject *
262
unicode_encode_call_errorhandler(const char *errors,
263
       PyObject **errorHandler,const char *encoding, const char *reason,
264
       PyObject *unicode, PyObject **exceptionObject,
265
       Py_ssize_t startpos, Py_ssize_t endpos, Py_ssize_t *newpos);
266
267
static void
268
raise_encode_exception(PyObject **exceptionObject,
269
                       const char *encoding,
270
                       PyObject *unicode,
271
                       Py_ssize_t startpos, Py_ssize_t endpos,
272
                       const char *reason);
273
274
/* Same for linebreaks */
275
static const unsigned char ascii_linebreak[] = {
276
    0, 0, 0, 0, 0, 0, 0, 0,
277
/*         0x000A, * LINE FEED */
278
/*         0x000B, * LINE TABULATION */
279
/*         0x000C, * FORM FEED */
280
/*         0x000D, * CARRIAGE RETURN */
281
    0, 0, 1, 1, 1, 1, 0, 0,
282
    0, 0, 0, 0, 0, 0, 0, 0,
283
/*         0x001C, * FILE SEPARATOR */
284
/*         0x001D, * GROUP SEPARATOR */
285
/*         0x001E, * RECORD SEPARATOR */
286
    0, 0, 0, 0, 1, 1, 1, 0,
287
    0, 0, 0, 0, 0, 0, 0, 0,
288
    0, 0, 0, 0, 0, 0, 0, 0,
289
    0, 0, 0, 0, 0, 0, 0, 0,
290
    0, 0, 0, 0, 0, 0, 0, 0,
291
292
    0, 0, 0, 0, 0, 0, 0, 0,
293
    0, 0, 0, 0, 0, 0, 0, 0,
294
    0, 0, 0, 0, 0, 0, 0, 0,
295
    0, 0, 0, 0, 0, 0, 0, 0,
296
    0, 0, 0, 0, 0, 0, 0, 0,
297
    0, 0, 0, 0, 0, 0, 0, 0,
298
    0, 0, 0, 0, 0, 0, 0, 0,
299
    0, 0, 0, 0, 0, 0, 0, 0
300
};
301
302
#include "clinic/unicodeobject.c.h"
303
304
typedef enum {
305
    _Py_ERROR_UNKNOWN=0,
306
    _Py_ERROR_STRICT,
307
    _Py_ERROR_SURROGATEESCAPE,
308
    _Py_ERROR_REPLACE,
309
    _Py_ERROR_IGNORE,
310
    _Py_ERROR_BACKSLASHREPLACE,
311
    _Py_ERROR_SURROGATEPASS,
312
    _Py_ERROR_XMLCHARREFREPLACE,
313
    _Py_ERROR_OTHER
314
} _Py_error_handler;
315
316
static _Py_error_handler
317
get_error_handler(const char *errors)
318
{
319
    if (errors == NULL || strcmp(errors, "strict") == 0) {
inline
                          
strcmp will not be inlined into get_error_handler because its definition is unavailable 
get_error_handler
320
        return _Py_ERROR_STRICT;
321
    }
322
    if (strcmp(errors, "surrogateescape") == 0) {
inline
        
strcmp will not be inlined into get_error_handler because its definition is unavailable 
get_error_handler
323
        return _Py_ERROR_SURROGATEESCAPE;
324
    }
325
    if (strcmp(errors, "replace") == 0) {
inline
        
strcmp will not be inlined into get_error_handler because its definition is unavailable 
get_error_handler
326
        return _Py_ERROR_REPLACE;
327
    }
328
    if (strcmp(errors, "ignore") == 0) {
inline
        
strcmp will not be inlined into get_error_handler because its definition is unavailable 
get_error_handler
329
        return _Py_ERROR_IGNORE;
330
    }
331
    if (strcmp(errors, "backslashreplace") == 0) {
inline
        
strcmp will not be inlined into get_error_handler because its definition is unavailable 
get_error_handler
332
        return _Py_ERROR_BACKSLASHREPLACE;
333
    }
334
    if (strcmp(errors, "surrogatepass") == 0) {
inline
        
strcmp will not be inlined into get_error_handler because its definition is unavailable 
get_error_handler
335
        return _Py_ERROR_SURROGATEPASS;
336
    }
337
    if (strcmp(errors, "xmlcharrefreplace") == 0) {
inline
        
strcmp will not be inlined into get_error_handler because its definition is unavailable 
get_error_handler
338
        return _Py_ERROR_XMLCHARREFREPLACE;
339
    }
340
    return _Py_ERROR_OTHER;
341
}
342
343
/* The max unicode value is always 0x10FFFF while using the PEP-393 API.
344
   This function is kept for backward compatibility with the old API. */
345
Py_UNICODE
346
PyUnicode_GetMax(void)
347
{
348
#ifdef Py_UNICODE_WIDE
349
    return 0x10FFFF;
350
#else
351
    /* This is actually an illegal character, so it should
352
       not be passed to unichr. */
353
    return 0xFFFF;
354
#endif
355
}
356
357
#ifdef Py_DEBUG
358
int
359
_PyUnicode_CheckConsistency(PyObject *op, int check_content)
360
{
361
    PyASCIIObject *ascii;
362
    unsigned int kind;
363
364
    assert(PyUnicode_Check(op));
365
366
    ascii = (PyASCIIObject *)op;
367
    kind = ascii->state.kind;
368
369
    if (ascii->state.ascii == 1 && ascii->state.compact == 1) {
370
        assert(kind == PyUnicode_1BYTE_KIND);
371
        assert(ascii->state.ready == 1);
372
    }
373
    else {
374
        PyCompactUnicodeObject *compact = (PyCompactUnicodeObject *)op;
375
        void *data;
376
377
        if (ascii->state.compact == 1) {
378
            data = compact + 1;
379
            assert(kind == PyUnicode_1BYTE_KIND
380
                   || kind == PyUnicode_2BYTE_KIND
381
                   || kind == PyUnicode_4BYTE_KIND);
382
            assert(ascii->state.ascii == 0);
383
            assert(ascii->state.ready == 1);
384
            assert (compact->utf8 != data);
385
        }
386
        else {
387
            PyUnicodeObject *unicode = (PyUnicodeObject *)op;
388
389
            data = unicode->data.any;
390
            if (kind == PyUnicode_WCHAR_KIND) {
391
                assert(ascii->length == 0);
392
                assert(ascii->hash == -1);
393
                assert(ascii->state.compact == 0);
394
                assert(ascii->state.ascii == 0);
395
                assert(ascii->state.ready == 0);
396
                assert(ascii->state.interned == SSTATE_NOT_INTERNED);
397
                assert(ascii->wstr != NULL);
398
                assert(data == NULL);
399
                assert(compact->utf8 == NULL);
400
            }
401
            else {
402
                assert(kind == PyUnicode_1BYTE_KIND
403
                       || kind == PyUnicode_2BYTE_KIND
404
                       || kind == PyUnicode_4BYTE_KIND);
405
                assert(ascii->state.compact == 0);
406
                assert(ascii->state.ready == 1);
407
                assert(data != NULL);
408
                if (ascii->state.ascii) {
409
                    assert (compact->utf8 == data);
410
                    assert (compact->utf8_length == ascii->length);
411
                }
412
                else
413
                    assert (compact->utf8 != data);
414
            }
415
        }
416
        if (kind != PyUnicode_WCHAR_KIND) {
417
            if (
418
#if SIZEOF_WCHAR_T == 2
419
                kind == PyUnicode_2BYTE_KIND
420
#else
421
                kind == PyUnicode_4BYTE_KIND
422
#endif
423
               )
424
            {
425
                assert(ascii->wstr == data);
426
                assert(compact->wstr_length == ascii->length);
427
            } else
428
                assert(ascii->wstr != data);
429
        }
430
431
        if (compact->utf8 == NULL)
432
            assert(compact->utf8_length == 0);
433
        if (ascii->wstr == NULL)
434
            assert(compact->wstr_length == 0);
435
    }
436
    /* check that the best kind is used */
437
    if (check_content && kind != PyUnicode_WCHAR_KIND)
438
    {
439
        Py_ssize_t i;
440
        Py_UCS4 maxchar = 0;
441
        void *data;
442
        Py_UCS4 ch;
443
444
        data = PyUnicode_DATA(ascii);
445
        for (i=0; i < ascii->length; i++)
446
        {
447
            ch = PyUnicode_READ(kind, data, i);
448
            if (ch > maxchar)
449
                maxchar = ch;
450
        }
451
        if (kind == PyUnicode_1BYTE_KIND) {
452
            if (ascii->state.ascii == 0) {
453
                assert(maxchar >= 128);
454
                assert(maxchar <= 255);
455
            }
456
            else
457
                assert(maxchar < 128);
458
        }
459
        else if (kind == PyUnicode_2BYTE_KIND) {
460
            assert(maxchar >= 0x100);
461
            assert(maxchar <= 0xFFFF);
462
        }
463
        else {
464
            assert(maxchar >= 0x10000);
465
            assert(maxchar <= MAX_UNICODE);
466
        }
467
        assert(PyUnicode_READ(kind, data, ascii->length) == 0);
468
    }
469
    return 1;
470
}
471
#endif
472
473
static PyObject*
474
unicode_result_wchar(PyObject *unicode)
475
{
476
#ifndef Py_DEBUG
477
    Py_ssize_t len;
478
479
    len = _PyUnicode_WSTR_LENGTH(unicode);
480
    if (len == 0) {
481
        Py_DECREF(unicode);
482
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
unicode_result_wchar
inline
        
PyUnicode_New will not be inlined into unicode_result_wchar 
unicode_result_wchar
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_result_wchar
gvn
        
load of type %struct._object* eliminated in favor of phi 
unicode_result_wchar
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
unicode_result
inline
        
PyUnicode_New will not be inlined into unicode_result 
unicode_result
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_result
483
    }
484
485
    if (len == 1) {
486
        wchar_t ch = _PyUnicode_WSTR(unicode)[0];
487
        if ((Py_UCS4)ch < 256) {
488
            PyObject *latin1_char = get_latin1_char((unsigned char)ch);
inline
                                    
get_latin1_char can be inlined into unicode_result_wchar with cost=110 (threshold=250) 
unicode_result_wchar
inline
                                    
get_latin1_char inlined into unicode_result_wchar 
unicode_result_wchar
489
            Py_DECREF(unicode);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_result_wchar
gvn
            
load of type i64 not eliminated because it is clobbered by store 
unicode_result_wchar
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_result_wchar
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_result_wchar
gvn
            
load of type i64 not eliminated because it is clobbered by store 
unicode_result
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_result
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_result
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_result
490
            return latin1_char;
491
        }
492
    }
493
494
    if (_PyUnicode_Ready(unicode) < 0) {
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_result_wchar
inline
        
_PyUnicode_Ready will not be inlined into unicode_result_wchar 
unicode_result_wchar
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_result
inline
        
_PyUnicode_Ready will not be inlined into unicode_result 
unicode_result
495
        Py_DECREF(unicode);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_result_wchar
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_result_wchar
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_result
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_result
496
        return NULL;
497
    }
498
#else
499
    assert(Py_REFCNT(unicode) == 1);
500
501
    /* don't make the result ready in debug mode to ensure that the caller
502
       makes the string ready before using it */
503
    assert(_PyUnicode_CheckConsistency(unicode, 1));
504
#endif
505
    return unicode;
506
}
507
508
static PyObject*
509
unicode_result_ready(PyObject *unicode)
510
{
511
    Py_ssize_t length;
512
513
    length = PyUnicode_GET_LENGTH(unicode);
514
    if (length == 0) {
515
        if (unicode != unicode_empty) {
516
            Py_DECREF(unicode);
517
            _Py_RETURN_UNICODE_EMPTY();
inline
            
PyUnicode_New too costly to inline (cost=290, threshold=250) 
unicode_result_ready
inline
            
PyUnicode_New will not be inlined into unicode_result_ready 
unicode_result_ready
gvn
            
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_result_ready
gvn
            
load eliminated by PRE 
unicode_result_ready
gvn
            
load of type %struct._object* eliminated in favor of phi 
unicode_result_ready
518
        }
519
        return unicode_empty;
520
    }
521
522
    if (length == 1) {
523
        void *data = PyUnicode_DATA(unicode);
524
        int kind = PyUnicode_KIND(unicode);
525
        Py_UCS4 ch = PyUnicode_READ(kind, data, 0);
526
        if (ch < 256) {
527
            PyObject *latin1_char = unicode_latin1[ch];
528
            if (latin1_char != NULL) {
529
                if (unicode != latin1_char) {
530
                    Py_INCREF(latin1_char);
531
                    Py_DECREF(unicode);
gvn
                    
load of type i64 not eliminated because it is clobbered by store 
unicode_result_ready
532
                }
533
                return latin1_char;
534
            }
535
            else {
536
                assert(_PyUnicode_CheckConsistency(unicode, 1));
537
                Py_INCREF(unicode);
538
                unicode_latin1[ch] = unicode;
539
                return unicode;
540
            }
541
        }
542
    }
543
544
    assert(_PyUnicode_CheckConsistency(unicode, 1));
545
    return unicode;
546
}
547
548
static PyObject*
549
unicode_result(PyObject *unicode)
550
{
551
    assert(_PyUnicode_CHECK(unicode));
552
    if (PyUnicode_IS_READY(unicode))
553
        return unicode_result_ready(unicode);
inline
               
unicode_result_ready too costly to inline (cost=335, threshold=250) 
unicode_result
inline
               
unicode_result_ready will not be inlined into unicode_result 
unicode_result
554
    else
555
        return unicode_result_wchar(unicode);
inline
               
unicode_result_wchar can be inlined into unicode_result with cost=-14590 (threshold=250) 
unicode_result
inline
               
unicode_result_wchar inlined into unicode_result 
unicode_result
556
}
557
558
static PyObject*
559
unicode_result_unchanged(PyObject *unicode)
560
{
561
    if (PyUnicode_CheckExact(unicode)) {
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Substring
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
replace
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
replace
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
replace
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_subscript
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_capitalize
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_center
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_center
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_expandtabs
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_expandtabs
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_ljust
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_ljust
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_rjust
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_rjust
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_zfill
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_zfill
562
        if (PyUnicode_READY(unicode) == -1)
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_result_unchanged
inline
            
_PyUnicode_Ready will not be inlined into unicode_result_unchanged 
unicode_result_unchanged
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Substring
inline
            
_PyUnicode_Ready will not be inlined into PyUnicode_Substring 
PyUnicode_Substring
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Substring
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
replace
inline
            
_PyUnicode_Ready will not be inlined into replace 
replace
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
replace
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
replace
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
replace
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_str
inline
            
_PyUnicode_Ready will not be inlined into unicode_str 
unicode_str
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_repeat
inline
            
_PyUnicode_Ready will not be inlined into unicode_repeat 
unicode_repeat
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_subscript
inline
            
_PyUnicode_Ready will not be inlined into unicode_subscript 
unicode_subscript
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_subscript
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_capitalize
inline
            
_PyUnicode_Ready will not be inlined into unicode_capitalize 
unicode_capitalize
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_capitalize
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
pad
inline
            
_PyUnicode_Ready will not be inlined into pad 
pad
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_center
inline
            
_PyUnicode_Ready will not be inlined into unicode_center 
unicode_center
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_center
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_expandtabs
inline
            
_PyUnicode_Ready will not be inlined into unicode_expandtabs 
unicode_expandtabs
gvn
            
load of type i32 eliminated in favor of phi 
unicode_expandtabs
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_ljust
inline
            
_PyUnicode_Ready will not be inlined into unicode_ljust 
unicode_ljust
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_ljust
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_rjust
inline
            
_PyUnicode_Ready will not be inlined into unicode_rjust 
unicode_rjust
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_rjust
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_zfill
inline
            
_PyUnicode_Ready will not be inlined into unicode_zfill 
unicode_zfill
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_zfill
563
            return NULL;
564
        Py_INCREF(unicode);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_result_unchanged
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Substring
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Substring
gvn
        
load of type i64 not eliminated because it is clobbered by call 
replace
gvn
        
load of type i64 not eliminated because it is clobbered by call 
replace
gvn
        
load of type i64 not eliminated because it is clobbered by call 
replace
gvn
        
load of type i64 not eliminated because it is clobbered by call 
replace
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_str
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_repeat
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_subscript
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_subscript
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_capitalize
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_capitalize
gvn
        
load of type i64 not eliminated because it is clobbered by call 
pad
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_center
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_center
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_center
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_expandtabs
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_expandtabs
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_expandtabs
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_ljust
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_ljust
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_ljust
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_rjust
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_rjust
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_rjust
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_zfill
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_zfill
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_zfill
565
        return unicode;
566
    }
567
    else
568
        /* Subtype -- return genuine unicode string with the same value. */
569
        return _PyUnicode_Copy(unicode);
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
unicode_result_unchanged
inline
               
_PyUnicode_Copy will not be inlined into unicode_result_unchanged 
unicode_result_unchanged
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
PyUnicode_Substring
inline
               
_PyUnicode_Copy will not be inlined into PyUnicode_Substring 
PyUnicode_Substring
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
replace
inline
               
_PyUnicode_Copy will not be inlined into replace 
replace
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
unicode_str
inline
               
_PyUnicode_Copy will not be inlined into unicode_str 
unicode_str
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
unicode_repeat
inline
               
_PyUnicode_Copy will not be inlined into unicode_repeat 
unicode_repeat
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
unicode_subscript
inline
               
_PyUnicode_Copy will not be inlined into unicode_subscript 
unicode_subscript
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
unicode_capitalize
inline
               
_PyUnicode_Copy will not be inlined into unicode_capitalize 
unicode_capitalize
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
pad
inline
               
_PyUnicode_Copy will not be inlined into pad 
pad
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
unicode_center
inline
               
_PyUnicode_Copy will not be inlined into unicode_center 
unicode_center
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
unicode_expandtabs
inline
               
_PyUnicode_Copy will not be inlined into unicode_expandtabs 
unicode_expandtabs
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
unicode_ljust
inline
               
_PyUnicode_Copy will not be inlined into unicode_ljust 
unicode_ljust
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
unicode_rjust
inline
               
_PyUnicode_Copy will not be inlined into unicode_rjust 
unicode_rjust
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
unicode_zfill
inline
               
_PyUnicode_Copy will not be inlined into unicode_zfill 
unicode_zfill
570
}
571
572
/* Implementation of the "backslashreplace" error handler for 8-bit encodings:
573
   ASCII, Latin1, UTF-8, etc. */
574
static char*
575
backslashreplace(_PyBytesWriter *writer, char *str,
576
                 PyObject *unicode, Py_ssize_t collstart, Py_ssize_t collend)
577
{
578
    Py_ssize_t size, i;
579
    Py_UCS4 ch;
580
    enum PyUnicode_Kind kind;
581
    void *data;
582
583
    assert(PyUnicode_IS_READY(unicode));
584
    kind = PyUnicode_KIND(unicode);
585
    data = PyUnicode_DATA(unicode);
586
587
    size = 0;
588
    /* determine replacement size */
589
    for (i = collstart; i < collend; ++i) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
backslashreplace
loop-vectorize
    
loop not vectorized 
backslashreplace
590
        Py_ssize_t incr;
591
592
        ch = PyUnicode_READ(kind, data, i);
licm
             
hosting trunc 
backslashreplace
licm
             
hosting bitcast 
backslashreplace
593
        if (ch < 0x100)
594
            incr = 2+2;
595
        else if (ch < 0x10000)
596
            incr = 2+4;
597
        else {
598
            assert(ch <= MAX_UNICODE);
599
            incr = 2+8;
600
        }
601
        if (size > PY_SSIZE_T_MAX - incr) {
602
            PyErr_SetString(PyExc_OverflowError,
inline
            
PyErr_SetString will not be inlined into backslashreplace because its definition is unavailable 
backslashreplace
603
                            "encoded result is too long for a Python string");
604
            return NULL;
605
        }
606
        size += incr;
607
    }
608
609
    str = _PyBytesWriter_Prepare(writer, str, size);
inline
          
_PyBytesWriter_Prepare will not be inlined into backslashreplace because its definition is unavailable 
backslashreplace
610
    if (str == NULL)
611
        return NULL;
612
613
    /* generate replacement */
614
    for (i = collstart; i < collend; ++i) {
loop-vectorize
    
loop not vectorized 
backslashreplace
loop-vectorize
    
loop not vectorized: cannot identify array bounds 
backslashreplace
loop-unroll
    
unrolled loop by a factor of 2 with run-time trip count 
backslashreplace
615
        ch = PyUnicode_READ(kind, data, i);
licm
             
hosting trunc 
backslashreplace
licm
             
hosting bitcast 
backslashreplace
licm
             
hosting icmp 
backslashreplace
616
        *str++ = '\\';
617
        if (ch >= 0x00010000) {
loop-vectorize
            
loop not vectorized: control flow cannot be substituted for a select 
backslashreplace
618
            *str++ = 'U';
619
            *str++ = Py_hexdigits[(ch>>28)&0xf];
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
backslashreplace
gvn
                     
load of type i8* not eliminated because it is clobbered by store 
backslashreplace
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
backslashreplace
620
            *str++ = Py_hexdigits[(ch>>24)&0xf];
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
backslashreplace
gvn
                     
load of type i8* not eliminated in favor of load because it is clobbered by store 
backslashreplace
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
backslashreplace
621
            *str++ = Py_hexdigits[(ch>>20)&0xf];
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
backslashreplace
gvn
                     
load of type i8* not eliminated because it is clobbered by store 
backslashreplace
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
backslashreplace
622
            *str++ = Py_hexdigits[(ch>>16)&0xf];
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
backslashreplace
gvn
                     
load of type i8* not eliminated in favor of load because it is clobbered by store 
backslashreplace
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
backslashreplace
623
            *str++ = Py_hexdigits[(ch>>12)&0xf];
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
backslashreplace
gvn
                     
load of type i8* not eliminated because it is clobbered by store 
backslashreplace
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
backslashreplace
624
            *str++ = Py_hexdigits[(ch>>8)&0xf];
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
backslashreplace
gvn
                     
load of type i8* not eliminated in favor of load because it is clobbered by store 
backslashreplace
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
backslashreplace
625
        }
626
        else if (ch >= 0x100) {
627
            *str++ = 'u';
628
            *str++ = Py_hexdigits[(ch>>12)&0xf];
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
backslashreplace
gvn
                     
load of type i8* not eliminated because it is clobbered by store 
backslashreplace
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
backslashreplace
629
            *str++ = Py_hexdigits[(ch>>8)&0xf];
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
backslashreplace
gvn
                     
load of type i8* not eliminated in favor of load because it is clobbered by store 
backslashreplace
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
backslashreplace
630
        }
631
        else
632
            *str++ = 'x';
633
        *str++ = Py_hexdigits[(ch>>4)&0xf];
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
backslashreplace
gvn
                 
load of type i8* not eliminated because it is clobbered by store 
backslashreplace
gvn
                 
load of type i8* not eliminated because it is clobbered by store 
backslashreplace
gvn
                 
load of type i8* not eliminated because it is clobbered by store 
backslashreplace
gvn
                 
load of type i8* not eliminated because it is clobbered by store 
backslashreplace
634
        *str++ = Py_hexdigits[ch&0xf];
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
backslashreplace
gvn
                 
load of type i8* not eliminated in favor of load because it is clobbered by store 
backslashreplace
gvn
                 
load of type i8 not eliminated because it is clobbered by store 
backslashreplace
635
    }
636
    return str;
637
}
638
639
/* Implementation of the "xmlcharrefreplace" error handler for 8-bit encodings:
640
   ASCII, Latin1, UTF-8, etc. */
641
static char*
642
xmlcharrefreplace(_PyBytesWriter *writer, char *str,
643
                  PyObject *unicode, Py_ssize_t collstart, Py_ssize_t collend)
644
{
645
    Py_ssize_t size, i;
646
    Py_UCS4 ch;
647
    enum PyUnicode_Kind kind;
648
    void *data;
649
650
    assert(PyUnicode_IS_READY(unicode));
651
    kind = PyUnicode_KIND(unicode);
652
    data = PyUnicode_DATA(unicode);
653
654
    size = 0;
655
    /* determine replacement size */
656
    for (i = collstart; i < collend; ++i) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
xmlcharrefreplace
loop-vectorize
    
loop not vectorized 
xmlcharrefreplace
657
        Py_ssize_t incr;
658
659
        ch = PyUnicode_READ(kind, data, i);
licm
             
hosting trunc 
xmlcharrefreplace
licm
             
hosting bitcast 
xmlcharrefreplace
660
        if (ch < 10)
661
            incr = 2+1+1;
662
        else if (ch < 100)
663
            incr = 2+2+1;
664
        else if (ch < 1000)
665
            incr = 2+3+1;
666
        else if (ch < 10000)
667
            incr = 2+4+1;
668
        else if (ch < 100000)
669
            incr = 2+5+1;
670
        else if (ch < 1000000)
671
            incr = 2+6+1;
672
        else {
673
            assert(ch <= MAX_UNICODE);
674
            incr = 2+7+1;
675
        }
676
        if (size > PY_SSIZE_T_MAX - incr) {
677
            PyErr_SetString(PyExc_OverflowError,
inline
            
PyErr_SetString will not be inlined into xmlcharrefreplace because its definition is unavailable 
xmlcharrefreplace
678
                            "encoded result is too long for a Python string");
679
            return NULL;
680
        }
681
        size += incr;
682
    }
683
684
    str = _PyBytesWriter_Prepare(writer, str, size);
inline
          
_PyBytesWriter_Prepare will not be inlined into xmlcharrefreplace because its definition is unavailable 
xmlcharrefreplace
685
    if (str == NULL)
686
        return NULL;
687
688
    /* generate replacement */
689
    for (i = collstart; i < collend; ++i) {
loop-vectorize
    
loop not vectorized: value that could not be identified as reduction is used outside the loop 
xmlcharrefreplace
loop-vectorize
    
loop not vectorized 
xmlcharrefreplace
690
        str += sprintf(str, "&#%d;", PyUnicode_READ(kind, data, i));
inline
               
sprintf will not be inlined into xmlcharrefreplace because its definition is unavailable 
xmlcharrefreplace
licm
                                     
hosting trunc 
xmlcharrefreplace
licm
                                     
hosting bitcast 
xmlcharrefreplace
691
    }
692
    return str;
693
}
694
695
/* --- Bloom Filters ----------------------------------------------------- */
696
697
/* stuff to implement simple "bloom filters" for Unicode characters.
698
   to keep things simple, we use a single bitmask, using the least 5
699
   bits from each unicode characters as the bit index. */
700
701
/* the linebreak mask is set up by Unicode_Init below */
702
703
#if LONG_BIT >= 128
704
#define BLOOM_WIDTH 128
705
#elif LONG_BIT >= 64
706
#define BLOOM_WIDTH 64
707
#elif LONG_BIT >= 32
708
#define BLOOM_WIDTH 32
709
#else
710
#error "LONG_BIT is smaller than 32"
711
#endif
712
713
#define BLOOM_MASK unsigned long
714
715
static BLOOM_MASK bloom_linebreak = ~(BLOOM_MASK)0;
716
717
#define BLOOM(mask, ch)     ((mask &  (1UL << ((ch) & (BLOOM_WIDTH - 1)))))
718
719
#define BLOOM_LINEBREAK(ch)                                             \
720
    ((ch) < 128U ? ascii_linebreak[(ch)] :                              \
721
     (BLOOM(bloom_linebreak, (ch)) && Py_UNICODE_ISLINEBREAK(ch)))
722
723
static inline BLOOM_MASK
724
make_bloom_mask(int kind, void* ptr, Py_ssize_t len)
725
{
726
#define BLOOM_UPDATE(TYPE, MASK, PTR, LEN)             \
727
    do {                                               \
728
        TYPE *data = (TYPE *)PTR;                      \
729
        TYPE *end = data + LEN;                        \
730
        Py_UCS4 ch;                                    \
731
        for (; data != end; data++) {                  \
732
            ch = *data;                                \
733
            MASK |= (1UL << (ch & (BLOOM_WIDTH - 1))); \
734
        }                                              \
735
        break;                                         \
736
    } while (0)
737
738
    /* calculate simple bloom-style bitmask for a given unicode string */
739
740
    BLOOM_MASK mask;
741
742
    mask = 0;
743
    switch (kind) {
744
    case PyUnicode_1BYTE_KIND:
745
        BLOOM_UPDATE(Py_UCS1, mask, ptr, len);
loop-vectorize
        
vectorized loop (vectorization width: 2, interleaved count: 2) 
_PyUnicode_XStrip
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
_PyUnicode_XStrip
746
        break;
747
    case PyUnicode_2BYTE_KIND:
748
        BLOOM_UPDATE(Py_UCS2, mask, ptr, len);
loop-unroll
        
completely unrolled loop with 8 iterations 
_PyUnicode_Init
gvn
        
load of type i16 eliminated in favor of 10 
_PyUnicode_Init
gvn
        
load of type i16 eliminated in favor of 13 
_PyUnicode_Init
gvn
        
load of type i16 eliminated in favor of 28 
_PyUnicode_Init
gvn
        
load of type i16 eliminated in favor of 29 
_PyUnicode_Init
gvn
        
load of type i16 eliminated in favor of 30 
_PyUnicode_Init
gvn
        
load of type i16 eliminated in favor of 133 
_PyUnicode_Init
gvn
        
load of type i16 not eliminated because it is clobbered by call 
_PyUnicode_Init
loop-vectorize
        
vectorized loop (vectorization width: 2, interleaved count: 2) 
_PyUnicode_XStrip
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
_PyUnicode_XStrip
749
        break;
750
    case PyUnicode_4BYTE_KIND:
751
        BLOOM_UPDATE(Py_UCS4, mask, ptr, len);
loop-vectorize
        
vectorized loop (vectorization width: 2, interleaved count: 2) 
_PyUnicode_XStrip
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
_PyUnicode_XStrip
752
        break;
753
    default:
754
        assert(0);
755
    }
756
    return mask;
757
758
#undef BLOOM_UPDATE
759
}
760
761
static int
762
ensure_unicode(PyObject *obj)
763
{
764
    if (!PyUnicode_Check(obj)) {
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Count
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Find
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Tailmatch
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Contains
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Concat
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Replace
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Split
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Partition
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_RPartition
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_RSplit
765
        PyErr_Format(PyExc_TypeError,
inline
        
PyErr_Format will not be inlined into ensure_unicode because its definition is unavailable 
ensure_unicode
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Count
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Find
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Tailmatch
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Contains
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Concat
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Replace
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Split
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Partition
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_RPartition
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_RSplit
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
parse_args_finds_unicode
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_count
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_find
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_index
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_rfind
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_rindex
766
                     "must be str, not %.100s",
767
                     Py_TYPE(obj)->tp_name);
768
        return -1;
769
    }
770
    return PyUnicode_READY(obj);
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
ensure_unicode
inline
           
_PyUnicode_Ready will not be inlined into ensure_unicode 
ensure_unicode
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Translate
inline
           
_PyUnicode_Ready will not be inlined into PyUnicode_Translate 
PyUnicode_Translate
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Count
inline
           
_PyUnicode_Ready will not be inlined into PyUnicode_Count 
PyUnicode_Count
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Count
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Find
inline
           
_PyUnicode_Ready will not be inlined into PyUnicode_Find 
PyUnicode_Find
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Find
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Tailmatch
inline
           
_PyUnicode_Ready will not be inlined into PyUnicode_Tailmatch 
PyUnicode_Tailmatch
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Tailmatch
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Splitlines
inline
           
_PyUnicode_Ready will not be inlined into PyUnicode_Splitlines 
PyUnicode_Splitlines
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Contains
inline
           
_PyUnicode_Ready will not be inlined into PyUnicode_Contains 
PyUnicode_Contains
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Contains
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Concat
inline
           
_PyUnicode_Ready will not be inlined into PyUnicode_Concat 
PyUnicode_Concat
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Concat
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Replace
inline
           
_PyUnicode_Ready will not be inlined into PyUnicode_Replace 
PyUnicode_Replace
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Replace
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Split
inline
           
_PyUnicode_Ready will not be inlined into PyUnicode_Split 
PyUnicode_Split
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Split
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Partition
inline
           
_PyUnicode_Ready will not be inlined into PyUnicode_Partition 
PyUnicode_Partition
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Partition
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_RPartition
inline
           
_PyUnicode_Ready will not be inlined into PyUnicode_RPartition 
PyUnicode_RPartition
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_RPartition
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_RSplit
inline
           
_PyUnicode_Ready will not be inlined into PyUnicode_RSplit 
PyUnicode_RSplit
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_RSplit
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Format
inline
           
_PyUnicode_Ready will not be inlined into PyUnicode_Format 
PyUnicode_Format
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
parse_args_finds_unicode
inline
           
_PyUnicode_Ready will not be inlined into parse_args_finds_unicode 
parse_args_finds_unicode
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_count
inline
           
_PyUnicode_Ready will not be inlined into unicode_count 
unicode_count
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_find
inline
           
_PyUnicode_Ready will not be inlined into unicode_find 
unicode_find
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_index
inline
           
_PyUnicode_Ready will not be inlined into unicode_index 
unicode_index
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_rfind
inline
           
_PyUnicode_Ready will not be inlined into unicode_rfind 
unicode_rfind
inline
           
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_rindex
inline
           
_PyUnicode_Ready will not be inlined into unicode_rindex 
unicode_rindex
771
}
772
773
/* Compilation of templated routines */
774
775
#include "stringlib/asciilib.h"
776
#include "stringlib/fastsearch.h"
777
#include "stringlib/partition.h"
778
#include "stringlib/split.h"
779
#include "stringlib/count.h"
780
#include "stringlib/find.h"
781
#include "stringlib/find_max_char.h"
782
#include "stringlib/localeutil.h"
783
#include "stringlib/undef.h"
784
785
#include "stringlib/ucs1lib.h"
786
#include "stringlib/fastsearch.h"
787
#include "stringlib/partition.h"
788
#include "stringlib/split.h"
789
#include "stringlib/count.h"
790
#include "stringlib/find.h"
791
#include "stringlib/replace.h"
792
#include "stringlib/find_max_char.h"
793
#include "stringlib/localeutil.h"
794
#include "stringlib/undef.h"
795
796
#include "stringlib/ucs2lib.h"
797
#include "stringlib/fastsearch.h"
798
#include "stringlib/partition.h"
799
#include "stringlib/split.h"
800
#include "stringlib/count.h"
801
#include "stringlib/find.h"
802
#include "stringlib/replace.h"
803
#include "stringlib/find_max_char.h"
804
#include "stringlib/localeutil.h"
805
#include "stringlib/undef.h"
806
807
#include "stringlib/ucs4lib.h"
808
#include "stringlib/fastsearch.h"
809
#include "stringlib/partition.h"
810
#include "stringlib/split.h"
811
#include "stringlib/count.h"
812
#include "stringlib/find.h"
813
#include "stringlib/replace.h"
814
#include "stringlib/find_max_char.h"
815
#include "stringlib/localeutil.h"
816
#include "stringlib/undef.h"
817
818
#include "stringlib/unicodedefs.h"
819
#include "stringlib/fastsearch.h"
820
#include "stringlib/count.h"
821
#include "stringlib/find.h"
822
#include "stringlib/undef.h"
823
824
/* --- Unicode Object ----------------------------------------------------- */
825
826
static PyObject *
827
fixup(PyObject *self, Py_UCS4 (*fixfct)(PyObject *s));
828
829
static inline Py_ssize_t
830
findchar(const void *s, int kind,
831
         Py_ssize_t size, Py_UCS4 ch,
832
         int direction)
833
{
834
    switch (kind) {
835
    case PyUnicode_1BYTE_KIND:
836
        if ((Py_UCS1) ch != ch)
837
            return -1;
838
        if (direction > 0)
839
            return ucs1lib_find_char((Py_UCS1 *) s, size, (Py_UCS1) ch);
inline
                   
Not inlining. Cost of inlining ucs1lib_find_char increases the cost of inlining findchar in other contexts 
findchar
inline
                   
ucs1lib_find_char will not be inlined into findchar 
findchar
inline
                   
ucs1lib_find_char can be inlined into PyUnicode_FSDecoder with cost=70 (threshold=325) 
PyUnicode_FSDecoder
inline
                   
ucs1lib_find_char inlined into PyUnicode_FSDecoder 
PyUnicode_FSDecoder
inline
                   
ucs1lib_find_char can be inlined into any_find_slice with cost=75 (threshold=325) 
any_find_slice
inline
                   
ucs1lib_find_char inlined into any_find_slice 
any_find_slice
inline
                   
ucs1lib_find_char can be inlined into PyUnicode_FindChar with cost=75 (threshold=325) 
PyUnicode_FindChar
inline
                   
ucs1lib_find_char inlined into PyUnicode_FindChar 
PyUnicode_FindChar
inline
                   
ucs1lib_find_char can be inlined into PyUnicode_Contains with cost=75 (threshold=325) 
PyUnicode_Contains
inline
                   
ucs1lib_find_char inlined into PyUnicode_Contains 
PyUnicode_Contains
inline
                   
ucs1lib_find_char can be inlined into replace with cost=-14925 (threshold=325) 
replace
inline
                   
ucs1lib_find_char inlined into replace 
replace
840
        else
841
            return ucs1lib_rfind_char((Py_UCS1 *) s, size, (Py_UCS1) ch);
inline
                   
Not inlining. Cost of inlining ucs1lib_rfind_char increases the cost of inlining findchar in other contexts 
findchar
inline
                   
ucs1lib_rfind_char will not be inlined into findchar 
findchar
inline
                   
ucs1lib_rfind_char can be inlined into any_find_slice with cost=65 (threshold=325) 
any_find_slice
inline
                   
ucs1lib_rfind_char inlined into any_find_slice 
any_find_slice
inline
                   
ucs1lib_rfind_char can be inlined into PyUnicode_FindChar with cost=65 (threshold=325) 
PyUnicode_FindChar
inline
                   
ucs1lib_rfind_char inlined into PyUnicode_FindChar 
PyUnicode_FindChar
842
    case PyUnicode_2BYTE_KIND:
843
        if ((Py_UCS2) ch != ch)
844
            return -1;
845
        if (direction > 0)
846
            return ucs2lib_find_char((Py_UCS2 *) s, size, (Py_UCS2) ch);
inline
                   
Not inlining. Cost of inlining ucs2lib_find_char increases the cost of inlining findchar in other contexts 
findchar
inline
                   
ucs2lib_find_char will not be inlined into findchar 
findchar
inline
                   
ucs2lib_find_char can be inlined into PyUnicode_FSDecoder with cost=15 (threshold=325) 
PyUnicode_FSDecoder
inline
                   
ucs2lib_find_char inlined into PyUnicode_FSDecoder 
PyUnicode_FSDecoder
inline
                   
ucs2lib_find_char can be inlined into any_find_slice with cost=145 (threshold=325) 
any_find_slice
inline
                   
ucs2lib_find_char inlined into any_find_slice 
any_find_slice
inline
                   
ucs2lib_find_char can be inlined into PyUnicode_FindChar with cost=145 (threshold=325) 
PyUnicode_FindChar
inline
                   
ucs2lib_find_char inlined into PyUnicode_FindChar 
PyUnicode_FindChar
inline
                   
ucs2lib_find_char can be inlined into PyUnicode_Contains with cost=145 (threshold=325) 
PyUnicode_Contains
inline
                   
ucs2lib_find_char inlined into PyUnicode_Contains 
PyUnicode_Contains
inline
                   
ucs2lib_find_char can be inlined into replace with cost=-14855 (threshold=325) 
replace
inline
                   
ucs2lib_find_char inlined into replace 
replace
847
        else
848
            return ucs2lib_rfind_char((Py_UCS2 *) s, size, (Py_UCS2) ch);
inline
                   
Not inlining. Cost of inlining ucs2lib_rfind_char increases the cost of inlining findchar in other contexts 
findchar
inline
                   
ucs2lib_rfind_char will not be inlined into findchar 
findchar
inline
                   
ucs2lib_rfind_char can be inlined into any_find_slice with cost=125 (threshold=325) 
any_find_slice
inline
                   
ucs2lib_rfind_char inlined into any_find_slice 
any_find_slice
inline
                   
ucs2lib_rfind_char can be inlined into PyUnicode_FindChar with cost=125 (threshold=325) 
PyUnicode_FindChar
inline
                   
ucs2lib_rfind_char inlined into PyUnicode_FindChar 
PyUnicode_FindChar
849
    case PyUnicode_4BYTE_KIND:
850
        if (direction > 0)
851
            return ucs4lib_find_char((Py_UCS4 *) s, size, ch);
inline
                   
Not inlining. Cost of inlining ucs4lib_find_char increases the cost of inlining findchar in other contexts 
findchar
inline
                   
ucs4lib_find_char will not be inlined into findchar 
findchar
inline
                   
ucs4lib_find_char can be inlined into PyUnicode_FSDecoder with cost=15 (threshold=325) 
PyUnicode_FSDecoder
inline
                   
ucs4lib_find_char inlined into PyUnicode_FSDecoder 
PyUnicode_FSDecoder
inline
                   
ucs4lib_find_char can be inlined into any_find_slice with cost=140 (threshold=325) 
any_find_slice
inline
                   
ucs4lib_find_char inlined into any_find_slice 
any_find_slice
inline
                   
ucs4lib_find_char can be inlined into PyUnicode_FindChar with cost=140 (threshold=325) 
PyUnicode_FindChar
inline
                   
ucs4lib_find_char inlined into PyUnicode_FindChar 
PyUnicode_FindChar
inline
                   
ucs4lib_find_char can be inlined into PyUnicode_Contains with cost=140 (threshold=325) 
PyUnicode_Contains
inline
                   
ucs4lib_find_char inlined into PyUnicode_Contains 
PyUnicode_Contains
inline
                   
ucs4lib_find_char can be inlined into replace with cost=-14860 (threshold=325) 
replace
inline
                   
ucs4lib_find_char inlined into replace 
replace
852
        else
853
            return ucs4lib_rfind_char((Py_UCS4 *) s, size, ch);
inline
                   
Not inlining. Cost of inlining ucs4lib_rfind_char increases the cost of inlining findchar in other contexts 
findchar
inline
                   
ucs4lib_rfind_char will not be inlined into findchar 
findchar
inline
                   
ucs4lib_rfind_char can be inlined into any_find_slice with cost=120 (threshold=325) 
any_find_slice
inline
                   
ucs4lib_rfind_char inlined into any_find_slice 
any_find_slice
inline
                   
ucs4lib_rfind_char can be inlined into PyUnicode_FindChar with cost=120 (threshold=325) 
PyUnicode_FindChar
inline
                   
ucs4lib_rfind_char inlined into PyUnicode_FindChar 
PyUnicode_FindChar
854
    default:
855
        assert(0);
856
        return -1;
857
    }
858
}
859
860
#ifdef Py_DEBUG
861
/* Fill the data of a Unicode string with invalid characters to detect bugs
862
   earlier.
863
864
   _PyUnicode_CheckConsistency(str, 1) detects invalid characters, at least for
865
   ASCII and UCS-4 strings. U+00FF is invalid in ASCII and U+FFFFFFFF is an
866
   invalid character in Unicode 6.0. */
867
static void
868
unicode_fill_invalid(PyObject *unicode, Py_ssize_t old_length)
869
{
870
    int kind = PyUnicode_KIND(unicode);
871
    Py_UCS1 *data = PyUnicode_1BYTE_DATA(unicode);
872
    Py_ssize_t length = _PyUnicode_LENGTH(unicode);
873
    if (length <= old_length)
874
        return;
875
    memset(data + old_length * kind, 0xff, (length - old_length) * kind);
876
}
877
#endif
878
879
static PyObject*
880
resize_compact(PyObject *unicode, Py_ssize_t length)
881
{
882
    Py_ssize_t char_size;
883
    Py_ssize_t struct_size;
884
    Py_ssize_t new_size;
885
    int share_wstr;
886
    PyObject *new_unicode;
887
#ifdef Py_DEBUG
888
    Py_ssize_t old_length = _PyUnicode_LENGTH(unicode);
889
#endif
890
891
    assert(unicode_modifiable(unicode));
892
    assert(PyUnicode_IS_READY(unicode));
893
    assert(PyUnicode_IS_COMPACT(unicode));
894
895
    char_size = PyUnicode_KIND(unicode);
896
    if (PyUnicode_IS_ASCII(unicode))
897
        struct_size = sizeof(PyASCIIObject);
898
    else
899
        struct_size = sizeof(PyCompactUnicodeObject);
900
    share_wstr = _PyUnicode_SHARE_WSTR(unicode);
901
902
    if (length > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1)) {
903
        PyErr_NoMemory();
inline
        
PyErr_NoMemory will not be inlined into resize_compact because its definition is unavailable 
resize_compact
904
        return NULL;
905
    }
906
    new_size = (struct_size + (length + 1) * char_size);
907
908
    if (_PyUnicode_HAS_UTF8_MEMORY(unicode)) {
gvn
        
load of type i32 eliminated in favor of load 
resize_compact
909
        PyObject_DEL(_PyUnicode_UTF8(unicode));
inline
        
PyObject_Free will not be inlined into resize_compact because its definition is unavailable 
resize_compact
gvn
                     
load of type i8* eliminated in favor of load 
resize_compact
910
        _PyUnicode_UTF8(unicode) = NULL;
911
        _PyUnicode_UTF8_LENGTH(unicode) = 0;
912
    }
913
    _Py_DEC_REFTOTAL;
914
    _Py_ForgetReference(unicode);
915
916
    new_unicode = (PyObject *)PyObject_REALLOC(unicode, new_size);
inline
                              
PyObject_Realloc will not be inlined into resize_compact because its definition is unavailable 
resize_compact
917
    if (new_unicode == NULL) {
918
        _Py_NewReference(unicode);
919
        PyErr_NoMemory();
inline
        
PyErr_NoMemory will not be inlined into resize_compact because its definition is unavailable 
resize_compact
920
        return NULL;
921
    }
922
    unicode = new_unicode;
923
    _Py_NewReference(unicode);
924
925
    _PyUnicode_LENGTH(unicode) = length;
926
    if (share_wstr) {
927
        _PyUnicode_WSTR(unicode) = PyUnicode_DATA(unicode);
gvn
                                   
load of type i32 not eliminated because it is clobbered by call 
resize_compact
gvn
                                   
load of type i8* not eliminated because it is clobbered by call 
resize_compact
928
        if (!PyUnicode_IS_ASCII(unicode))
929
            _PyUnicode_WSTR_LENGTH(unicode) = length;
930
    }
931
    else if (_PyUnicode_HAS_WSTR_MEMORY(unicode)) {
gvn
             
load of type i32* not eliminated because it is clobbered by call 
resize_compact
gvn
             
load of type i32 not eliminated because it is clobbered by call 
resize_compact
gvn
             
load of type i8* not eliminated because it is clobbered by call 
resize_compact
932
        PyObject_DEL(_PyUnicode_WSTR(unicode));
inline
        
PyObject_Free will not be inlined into resize_compact because its definition is unavailable 
resize_compact
gvn
                     
load of type i8* eliminated in favor of inttoptr 
resize_compact
933
        _PyUnicode_WSTR(unicode) = NULL;
934
        if (!PyUnicode_IS_ASCII(unicode))
gvn
             
load of type i32 not eliminated in favor of load because it is clobbered by call 
resize_compact
935
            _PyUnicode_WSTR_LENGTH(unicode) = 0;
936
    }
937
#ifdef Py_DEBUG
938
    unicode_fill_invalid(unicode, old_length);
939
#endif
940
    PyUnicode_WRITE(PyUnicode_KIND(unicode), PyUnicode_DATA(unicode),
gvn
    
load of type i32 not eliminated because it is clobbered by call 
resize_compact
gvn
    
load eliminated by PRE 
resize_compact
gvn
    
load of type i8* not eliminated because it is clobbered by call 
resize_compact
gvn
    
load of type i8* not eliminated because it is clobbered by call 
resize_compact
941
                    length, 0);
942
    assert(_PyUnicode_CheckConsistency(unicode, 0));
943
    return unicode;
944
}
945
946
static int
947
resize_inplace(PyObject *unicode, Py_ssize_t length)
948
{
949
    wchar_t *wstr;
950
    Py_ssize_t new_size;
951
    assert(!PyUnicode_IS_COMPACT(unicode));
952
    assert(Py_REFCNT(unicode) == 1);
953
954
    if (PyUnicode_IS_READY(unicode)) {
955
        Py_ssize_t char_size;
956
        int share_wstr, share_utf8;
957
        void *data;
958
#ifdef Py_DEBUG
959
        Py_ssize_t old_length = _PyUnicode_LENGTH(unicode);
960
#endif
961
962
        data = _PyUnicode_DATA_ANY(unicode);
963
        char_size = PyUnicode_KIND(unicode);
964
        share_wstr = _PyUnicode_SHARE_WSTR(unicode);
965
        share_utf8 = _PyUnicode_SHARE_UTF8(unicode);
gvn
                     
load of type i8* eliminated in favor of load 
resize_inplace
966
967
        if (length > (PY_SSIZE_T_MAX / char_size - 1)) {
968
            PyErr_NoMemory();
inline
            
PyErr_NoMemory will not be inlined into resize_inplace because its definition is unavailable 
resize_inplace
969
            return -1;
970
        }
971
        new_size = (length + 1) * char_size;
972
973
        if (!share_utf8 && _PyUnicode_HAS_UTF8_MEMORY(unicode))
gvn
                           
load of type i32 eliminated in favor of load 
resize_inplace
gvn
                           
load of type i8* eliminated in favor of load 
resize_inplace
gvn
                           
load of type i8* eliminated in favor of load 
resize_inplace
974
        {
975
            PyObject_DEL(_PyUnicode_UTF8(unicode));
inline
            
PyObject_Free will not be inlined into resize_inplace because its definition is unavailable 
resize_inplace
gvn
                         
load of type i8* eliminated in favor of load 
resize_inplace
976
            _PyUnicode_UTF8(unicode) = NULL;
977
            _PyUnicode_UTF8_LENGTH(unicode) = 0;
978
        }
979
980
        data = (PyObject *)PyObject_REALLOC(data, new_size);
inline
                           
PyObject_Realloc will not be inlined into resize_inplace because its definition is unavailable 
resize_inplace
981
        if (data == NULL) {
982
            PyErr_NoMemory();
inline
            
PyErr_NoMemory will not be inlined into resize_inplace because its definition is unavailable 
resize_inplace
983
            return -1;
984
        }
985
        _PyUnicode_DATA_ANY(unicode) = data;
986
        if (share_wstr) {
987
            _PyUnicode_WSTR(unicode) = data;
988
            _PyUnicode_WSTR_LENGTH(unicode) = length;
989
        }
990
        if (share_utf8) {
991
            _PyUnicode_UTF8(unicode) = data;
992
            _PyUnicode_UTF8_LENGTH(unicode) = length;
993
        }
994
        _PyUnicode_LENGTH(unicode) = length;
995
        PyUnicode_WRITE(PyUnicode_KIND(unicode), data, length, 0);
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
resize_inplace
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_resize
996
#ifdef Py_DEBUG
997
        unicode_fill_invalid(unicode, old_length);
998
#endif
999
        if (share_wstr || _PyUnicode_WSTR(unicode) == NULL) {
gvn
                          
load of type i32* not eliminated in favor of load because it is clobbered by store 
resize_inplace
gvn
                          
load of type i32* not eliminated in favor of load because it is clobbered by call 
resize_inplace
gvn
                          
load of type i32* not eliminated in favor of load because it is clobbered by store 
unicode_resize
gvn
                          
load of type i32* not eliminated in favor of load because it is clobbered by call 
unicode_resize
1000
            assert(_PyUnicode_CheckConsistency(unicode, 0));
1001
            return 0;
1002
        }
1003
    }
1004
    assert(_PyUnicode_WSTR(unicode) != NULL);
1005
1006
    /* check for integer overflow */
1007
    if (length > PY_SSIZE_T_MAX / (Py_ssize_t)sizeof(wchar_t) - 1) {
1008
        PyErr_NoMemory();
inline
        
PyErr_NoMemory will not be inlined into resize_inplace because its definition is unavailable 
resize_inplace
1009
        return -1;
1010
    }
1011
    new_size = sizeof(wchar_t) * (length + 1);
1012
    wstr =  _PyUnicode_WSTR(unicode);
1013
    wstr = PyObject_REALLOC(wstr, new_size);
inline
           
PyObject_Realloc will not be inlined into resize_inplace because its definition is unavailable 
resize_inplace
1014
    if (!wstr) {
1015
        PyErr_NoMemory();
inline
        
PyErr_NoMemory will not be inlined into resize_inplace because its definition is unavailable 
resize_inplace
1016
        return -1;
1017
    }
1018
    _PyUnicode_WSTR(unicode) = wstr;
1019
    _PyUnicode_WSTR(unicode)[length] = 0;
1020
    _PyUnicode_WSTR_LENGTH(unicode) = length;
1021
    assert(_PyUnicode_CheckConsistency(unicode, 0));
1022
    return 0;
1023
}
1024
1025
static PyObject*
1026
resize_copy(PyObject *unicode, Py_ssize_t length)
1027
{
1028
    Py_ssize_t copy_length;
1029
    if (_PyUnicode_KIND(unicode) != PyUnicode_WCHAR_KIND) {
gvn
        
load of type i32 eliminated in favor of load 
unicode_resize
1030
        PyObject *copy;
1031
1032
        if (PyUnicode_READY(unicode) == -1)
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
resize_copy
inline
            
_PyUnicode_Ready will not be inlined into resize_copy 
resize_copy
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_resize
inline
            
_PyUnicode_Ready will not be inlined into unicode_resize 
unicode_resize
1033
            return NULL;
1034
1035
        copy = PyUnicode_New(length, PyUnicode_MAX_CHAR_VALUE(unicode));
inline
               
PyUnicode_New too costly to inline (cost=460, threshold=250) 
resize_copy
inline
               
PyUnicode_New will not be inlined into resize_copy 
resize_copy
gvn
                                     
load of type i32 not eliminated in favor of load because it is clobbered by call 
resize_copy
gvn
                                     
load eliminated by PRE 
resize_copy
inline
               
PyUnicode_New too costly to inline (cost=460, threshold=250) 
unicode_resize
inline
               
PyUnicode_New will not be inlined into unicode_resize 
unicode_resize
1036
        if (copy == NULL)
1037
            return NULL;
1038
1039
        copy_length = Py_MIN(length, PyUnicode_GET_LENGTH(unicode));
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
resize_copy
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_resize
1040
        _PyUnicode_FastCopyCharacters(copy, 0, unicode, 0, copy_length);
inline
        
_PyUnicode_FastCopyCharacters can be inlined into resize_copy with cost=5 (threshold=375) 
resize_copy
inline
        
_PyUnicode_FastCopyCharacters inlined into resize_copy 
resize_copy
1041
        return copy;
1042
    }
1043
    else {
1044
        PyObject *w;
1045
1046
        w = (PyObject*)_PyUnicode_New(length);
inline
                       
_PyUnicode_New too costly to inline (cost=335, threshold=250) 
resize_copy
inline
                       
_PyUnicode_New will not be inlined into resize_copy 
resize_copy
inline
                       
_PyUnicode_New too costly to inline (cost=335, threshold=250) 
unicode_resize
inline
                       
_PyUnicode_New will not be inlined into unicode_resize 
unicode_resize
1047
        if (w == NULL)
1048
            return NULL;
1049
        copy_length = _PyUnicode_WSTR_LENGTH(unicode);
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
resize_copy
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_resize
1050
        copy_length = Py_MIN(copy_length, length);
1051
        memcpy(_PyUnicode_WSTR(w), _PyUnicode_WSTR(unicode),
gvn
               
load of type i8* not eliminated because it is clobbered by call 
resize_copy
gvn
                                   
load of type i8* not eliminated because it is clobbered by call 
resize_copy
gvn
               
load of type i8* not eliminated because it is clobbered by call 
unicode_resize
gvn
                                   
load of type i8* not eliminated because it is clobbered by call 
unicode_resize
1052
                  copy_length * sizeof(wchar_t));
1053
        return w;
1054
    }
1055
}
1056
1057
/* We allocate one more byte to make sure the string is
1058
   Ux0000 terminated; some code (e.g. new_identifier)
1059
   relies on that.
1060
1061
   XXX This allocator could further be enhanced by assuring that the
1062
   free list never reduces its size below 1.
1063
1064
*/
1065
1066
static PyUnicodeObject *
1067
_PyUnicode_New(Py_ssize_t length)
1068
{
1069
    PyUnicodeObject *unicode;
1070
    size_t new_size;
1071
1072
    /* Optimization for empty strings */
1073
    if (length == 0 && unicode_empty != NULL) {
1074
        Py_INCREF(unicode_empty);
1075
        return (PyUnicodeObject*)unicode_empty;
1076
    }
1077
1078
    /* Ensure we won't overflow the size. */
1079
    if (length > ((PY_SSIZE_T_MAX / (Py_ssize_t)sizeof(Py_UNICODE)) - 1)) {
1080
        return (PyUnicodeObject *)PyErr_NoMemory();
inline
                                  
PyErr_NoMemory will not be inlined into _PyUnicode_New because its definition is unavailable 
_PyUnicode_New
1081
    }
1082
    if (length < 0) {
1083
        PyErr_SetString(PyExc_SystemError,
inline
        
PyErr_SetString will not be inlined into _PyUnicode_New because its definition is unavailable 
_PyUnicode_New
1084
                        "Negative size passed to _PyUnicode_New");
1085
        return NULL;
1086
    }
1087
1088
    unicode = PyObject_New(PyUnicodeObject, &PyUnicode_Type);
inline
              
_PyObject_New will not be inlined into _PyUnicode_New because its definition is unavailable 
_PyUnicode_New
1089
    if (unicode == NULL)
1090
        return NULL;
1091
    new_size = sizeof(Py_UNICODE) * ((size_t)length + 1);
1092
1093
    _PyUnicode_WSTR_LENGTH(unicode) = length;
1094
    _PyUnicode_HASH(unicode) = -1;
1095
    _PyUnicode_STATE(unicode).interned = 0;
gvn
                                       
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_New
gvn
                                       
load of type i32 not eliminated because it is clobbered by call 
unicodeiter_reduce
1096
    _PyUnicode_STATE(unicode).kind = 0;
1097
    _PyUnicode_STATE(unicode).compact = 0;
1098
    _PyUnicode_STATE(unicode).ready = 0;
1099
    _PyUnicode_STATE(unicode).ascii = 0;
1100
    _PyUnicode_DATA_ANY(unicode) = NULL;
1101
    _PyUnicode_LENGTH(unicode) = 0;
1102
    _PyUnicode_UTF8(unicode) = NULL;
1103
    _PyUnicode_UTF8_LENGTH(unicode) = 0;
1104
1105
    _PyUnicode_WSTR(unicode) = (Py_UNICODE*) PyObject_MALLOC(new_size);
inline
                                             
PyObject_Malloc will not be inlined into _PyUnicode_New because its definition is unavailable 
_PyUnicode_New
1106
    if (!_PyUnicode_WSTR(unicode)) {
1107
        Py_DECREF(unicode);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_New
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_New
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicodeiter_reduce
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicodeiter_reduce
1108
        PyErr_NoMemory();
inline
        
PyErr_NoMemory will not be inlined into _PyUnicode_New because its definition is unavailable 
_PyUnicode_New
1109
        return NULL;
1110
    }
1111
1112
    /* Initialize the first element to guard against cases where
1113
     * the caller fails before initializing str -- unicode_resize()
1114
     * reads str[0], and the Keep-Alive optimization can keep memory
1115
     * allocated for str alive across a call to unicode_dealloc(unicode).
1116
     * We don't want unicode_resize to read uninitialized memory in
1117
     * that case.
1118
     */
1119
    _PyUnicode_WSTR(unicode)[0] = 0;
1120
    _PyUnicode_WSTR(unicode)[length] = 0;
gvn
    
load of type i32* eliminated in favor of inttoptr 
_PyUnicode_New
1121
1122
    assert(_PyUnicode_CheckConsistency((PyObject *)unicode, 0));
1123
    return unicode;
1124
}
1125
1126
static const char*
1127
unicode_kind_name(PyObject *unicode)
1128
{
1129
    /* don't check consistency: unicode_kind_name() is called from
1130
       _PyUnicode_Dump() */
1131
    if (!PyUnicode_IS_COMPACT(unicode))
gvn
         
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
         
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
1132
    {
1133
        if (!PyUnicode_IS_READY(unicode))
1134
            return "wstr";
1135
        switch (PyUnicode_KIND(unicode))
1136
        {
1137
        case PyUnicode_1BYTE_KIND:
1138
            if (PyUnicode_IS_ASCII(unicode))
1139
                return "legacy ascii";
1140
            else
1141
                return "legacy latin1";
1142
        case PyUnicode_2BYTE_KIND:
1143
            return "legacy UCS2";
1144
        case PyUnicode_4BYTE_KIND:
1145
            return "legacy UCS4";
1146
        default:
1147
            return "<legacy invalid kind>";
1148
        }
1149
    }
1150
    assert(PyUnicode_IS_READY(unicode));
1151
    switch (PyUnicode_KIND(unicode)) {
1152
    case PyUnicode_1BYTE_KIND:
1153
        if (PyUnicode_IS_ASCII(unicode))
1154
            return "ascii";
1155
        else
1156
            return "latin1";
1157
    case PyUnicode_2BYTE_KIND:
1158
        return "UCS2";
1159
    case PyUnicode_4BYTE_KIND:
1160
        return "UCS4";
1161
    default:
1162
        return "<invalid compact kind>";
1163
    }
1164
}
1165
1166
#ifdef Py_DEBUG
1167
/* Functions wrapping macros for use in debugger */
1168
char *_PyUnicode_utf8(void *unicode){
1169
    return PyUnicode_UTF8(unicode);
1170
}
1171
1172
void *_PyUnicode_compact_data(void *unicode) {
1173
    return _PyUnicode_COMPACT_DATA(unicode);
1174
}
1175
void *_PyUnicode_data(void *unicode){
1176
    printf("obj %p\n", unicode);
1177
    printf("compact %d\n", PyUnicode_IS_COMPACT(unicode));
1178
    printf("compact ascii %d\n", PyUnicode_IS_COMPACT_ASCII(unicode));
1179
    printf("ascii op %p\n", ((void*)((PyASCIIObject*)(unicode) + 1)));
1180
    printf("compact op %p\n", ((void*)((PyCompactUnicodeObject*)(unicode) + 1)));
1181
    printf("compact data %p\n", _PyUnicode_COMPACT_DATA(unicode));
1182
    return PyUnicode_DATA(unicode);
1183
}
1184
1185
void
1186
_PyUnicode_Dump(PyObject *op)
1187
{
1188
    PyASCIIObject *ascii = (PyASCIIObject *)op;
1189
    PyCompactUnicodeObject *compact = (PyCompactUnicodeObject *)op;
1190
    PyUnicodeObject *unicode = (PyUnicodeObject *)op;
1191
    void *data;
1192
1193
    if (ascii->state.compact)
1194
    {
1195
        if (ascii->state.ascii)
1196
            data = (ascii + 1);
1197
        else
1198
            data = (compact + 1);
1199
    }
1200
    else
1201
        data = unicode->data.any;
1202
    printf("%s: len=%" PY_FORMAT_SIZE_T "u, ",
1203
           unicode_kind_name(op), ascii->length);
1204
1205
    if (ascii->wstr == data)
1206
        printf("shared ");
1207
    printf("wstr=%p", ascii->wstr);
1208
1209
    if (!(ascii->state.ascii == 1 && ascii->state.compact == 1)) {
1210
        printf(" (%" PY_FORMAT_SIZE_T "u), ", compact->wstr_length);
1211
        if (!ascii->state.compact && compact->utf8 == unicode->data.any)
1212
            printf("shared ");
1213
        printf("utf8=%p (%" PY_FORMAT_SIZE_T "u)",
1214
               compact->utf8, compact->utf8_length);
1215
    }
1216
    printf(", data=%p\n", data);
1217
}
1218
#endif
1219
1220
PyObject *
1221
PyUnicode_New(Py_ssize_t size, Py_UCS4 maxchar)
1222
{
1223
    PyObject *obj;
1224
    PyCompactUnicodeObject *unicode;
1225
    void *data;
1226
    enum PyUnicode_Kind kind;
1227
    int is_sharing, is_ascii;
1228
    Py_ssize_t char_size;
1229
    Py_ssize_t struct_size;
1230
1231
    /* Optimization for empty strings */
1232
    if (size == 0 && unicode_empty != NULL) {
1233
        Py_INCREF(unicode_empty);
1234
        return unicode_empty;
1235
    }
1236
1237
    is_ascii = 0;
1238
    is_sharing = 0;
1239
    struct_size = sizeof(PyCompactUnicodeObject);
1240
    if (maxchar < 128) {
1241
        kind = PyUnicode_1BYTE_KIND;
1242
        char_size = 1;
1243
        is_ascii = 1;
1244
        struct_size = sizeof(PyASCIIObject);
1245
    }
1246
    else if (maxchar < 256) {
1247
        kind = PyUnicode_1BYTE_KIND;
1248
        char_size = 1;
1249
    }
1250
    else if (maxchar < 65536) {
1251
        kind = PyUnicode_2BYTE_KIND;
1252
        char_size = 2;
1253
        if (sizeof(wchar_t) == 2)
1254
            is_sharing = 1;
1255
    }
1256
    else {
1257
        if (maxchar > MAX_UNICODE) {
1258
            PyErr_SetString(PyExc_SystemError,
inline
            
PyErr_SetString will not be inlined into PyUnicode_New because its definition is unavailable 
PyUnicode_New
1259
                            "invalid maximum character passed to PyUnicode_New");
1260
            return NULL;
1261
        }
1262
        kind = PyUnicode_4BYTE_KIND;
1263
        char_size = 4;
1264
        if (sizeof(wchar_t) == 4)
1265
            is_sharing = 1;
1266
    }
1267
1268
    /* Ensure we won't overflow the size. */
1269
    if (size < 0) {
1270
        PyErr_SetString(PyExc_SystemError,
inline
        
PyErr_SetString will not be inlined into PyUnicode_New because its definition is unavailable 
PyUnicode_New
1271
                        "Negative size passed to PyUnicode_New");
1272
        return NULL;
1273
    }
1274
    if (size > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1))
1275
        return PyErr_NoMemory();
inline
               
PyErr_NoMemory will not be inlined into PyUnicode_New because its definition is unavailable 
PyUnicode_New
1276
1277
    /* Duplicated allocation code from _PyObject_New() instead of a call to
1278
     * PyObject_New() so we are able to allocate space for the object and
1279
     * it's data buffer.
1280
     */
1281
    obj = (PyObject *) PyObject_MALLOC(struct_size + (size + 1) * char_size);
inline
                       
PyObject_Malloc will not be inlined into PyUnicode_New because its definition is unavailable 
PyUnicode_New
1282
    if (obj == NULL)
1283
        return PyErr_NoMemory();
inline
               
PyErr_NoMemory will not be inlined into PyUnicode_New because its definition is unavailable 
PyUnicode_New
1284
    obj = PyObject_INIT(obj, &PyUnicode_Type);
1285
    if (obj == NULL)
1286
        return NULL;
1287
1288
    unicode = (PyCompactUnicodeObject *)obj;
1289
    if (is_ascii)
1290
        data = ((PyASCIIObject*)obj) + 1;
1291
    else
1292
        data = unicode + 1;
1293
    _PyUnicode_LENGTH(unicode) = size;
1294
    _PyUnicode_HASH(unicode) = -1;
1295
    _PyUnicode_STATE(unicode).interned = 0;
gvn
                                       
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_New
1296
    _PyUnicode_STATE(unicode).kind = kind;
1297
    _PyUnicode_STATE(unicode).compact = 1;
1298
    _PyUnicode_STATE(unicode).ready = 1;
1299
    _PyUnicode_STATE(unicode).ascii = is_ascii;
1300
    if (is_ascii) {
1301
        ((char*)data)[size] = 0;
1302
        _PyUnicode_WSTR(unicode) = NULL;
1303
    }
1304
    else if (kind == PyUnicode_1BYTE_KIND) {
1305
        ((char*)data)[size] = 0;
1306
        _PyUnicode_WSTR(unicode) = NULL;
1307
        _PyUnicode_WSTR_LENGTH(unicode) = 0;
1308
        unicode->utf8 = NULL;
1309
        unicode->utf8_length = 0;
1310
    }
1311
    else {
1312
        unicode->utf8 = NULL;
1313
        unicode->utf8_length = 0;
1314
        if (kind == PyUnicode_2BYTE_KIND)
1315
            ((Py_UCS2*)data)[size] = 0;
1316
        else /* kind == PyUnicode_4BYTE_KIND */
1317
            ((Py_UCS4*)data)[size] = 0;
1318
        if (is_sharing) {
1319
            _PyUnicode_WSTR_LENGTH(unicode) = size;
1320
            _PyUnicode_WSTR(unicode) = (wchar_t *)data;
1321
        }
1322
        else {
1323
            _PyUnicode_WSTR_LENGTH(unicode) = 0;
1324
            _PyUnicode_WSTR(unicode) = NULL;
1325
        }
1326
    }
1327
#ifdef Py_DEBUG
1328
    unicode_fill_invalid((PyObject*)unicode, 0);
1329
#endif
1330
    assert(_PyUnicode_CheckConsistency((PyObject*)unicode, 0));
1331
    return obj;
1332
}
1333
1334
#if SIZEOF_WCHAR_T == 2
1335
/* Helper function to convert a 16-bits wchar_t representation to UCS4, this
1336
   will decode surrogate pairs, the other conversions are implemented as macros
1337
   for efficiency.
1338
1339
   This function assumes that unicode can hold one more code point than wstr
1340
   characters for a terminating null character. */
1341
static void
1342
unicode_convert_wchar_to_ucs4(const wchar_t *begin, const wchar_t *end,
1343
                              PyObject *unicode)
1344
{
1345
    const wchar_t *iter;
1346
    Py_UCS4 *ucs4_out;
1347
1348
    assert(unicode != NULL);
1349
    assert(_PyUnicode_CHECK(unicode));
1350
    assert(_PyUnicode_KIND(unicode) == PyUnicode_4BYTE_KIND);
1351
    ucs4_out = PyUnicode_4BYTE_DATA(unicode);
1352
1353
    for (iter = begin; iter < end; ) {
1354
        assert(ucs4_out < (PyUnicode_4BYTE_DATA(unicode) +
1355
                           _PyUnicode_GET_LENGTH(unicode)));
1356
        if (Py_UNICODE_IS_HIGH_SURROGATE(iter[0])
1357
            && (iter+1) < end
1358
            && Py_UNICODE_IS_LOW_SURROGATE(iter[1]))
1359
        {
1360
            *ucs4_out++ = Py_UNICODE_JOIN_SURROGATES(iter[0], iter[1]);
1361
            iter += 2;
1362
        }
1363
        else {
1364
            *ucs4_out++ = *iter;
1365
            iter++;
1366
        }
1367
    }
1368
    assert(ucs4_out == (PyUnicode_4BYTE_DATA(unicode) +
1369
                        _PyUnicode_GET_LENGTH(unicode)));
1370
1371
}
1372
#endif
1373
1374
static int
1375
unicode_check_modifiable(PyObject *unicode)
1376
{
1377
    if (!unicode_modifiable(unicode)) {
inline
         
unicode_modifiable can be inlined into unicode_check_modifiable with cost=25 (threshold=250) 
unicode_check_modifiable
inline
         
unicode_modifiable inlined into unicode_check_modifiable 
unicode_check_modifiable
1378
        PyErr_SetString(PyExc_SystemError,
inline
        
PyErr_SetString will not be inlined into unicode_check_modifiable because its definition is unavailable 
unicode_check_modifiable
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Fill
1379
                        "Cannot modify a string currently used");
1380
        return -1;
1381
    }
1382
    return 0;
1383
}
1384
1385
static int
1386
_copy_characters(PyObject *to, Py_ssize_t to_start,
1387
                 PyObject *from, Py_ssize_t from_start,
1388
                 Py_ssize_t how_many, int check_maxchar)
1389
{
1390
    unsigned int from_kind, to_kind;
1391
    void *from_data, *to_data;
1392
1393
    assert(0 <= how_many);
1394
    assert(0 <= from_start);
1395
    assert(0 <= to_start);
1396
    assert(PyUnicode_Check(from));
1397
    assert(PyUnicode_IS_READY(from));
1398
    assert(from_start + how_many <= PyUnicode_GET_LENGTH(from));
1399
1400
    assert(PyUnicode_Check(to));
1401
    assert(PyUnicode_IS_READY(to));
1402
    assert(to_start + how_many <= PyUnicode_GET_LENGTH(to));
1403
1404
    if (how_many == 0)
1405
        return 0;
1406
1407
    from_kind = PyUnicode_KIND(from);
1408
    from_data = PyUnicode_DATA(from);
1409
    to_kind = PyUnicode_KIND(to);
1410
    to_data = PyUnicode_DATA(to);
1411
1412
#ifdef Py_DEBUG
1413
    if (!check_maxchar
1414
        && PyUnicode_MAX_CHAR_VALUE(from) > PyUnicode_MAX_CHAR_VALUE(to))
1415
    {
1416
        const Py_UCS4 to_maxchar = PyUnicode_MAX_CHAR_VALUE(to);
1417
        Py_UCS4 ch;
1418
        Py_ssize_t i;
1419
        for (i=0; i < how_many; i++) {
1420
            ch = PyUnicode_READ(from_kind, from_data, from_start + i);
1421
            assert(ch <= to_maxchar);
1422
        }
1423
    }
1424
#endif
1425
1426
    if (from_kind == to_kind) {
1427
        if (check_maxchar
1428
            && !PyUnicode_IS_ASCII(from) && PyUnicode_IS_ASCII(to))
gvn
                
load of type i32 eliminated in favor of load 
_copy_characters
gvn
                                            
load of type i32 eliminated in favor of load 
_copy_characters
1429
        {
1430
            /* Writing Latin-1 characters into an ASCII string requires to
1431
               check that all written characters are pure ASCII */
1432
            Py_UCS4 max_char;
1433
            max_char = ucs1lib_find_max_char(from_data,
inline
                       
ucs1lib_find_max_char can be inlined into _copy_characters with cost=60 (threshold=325) 
_copy_characters
inline
                       
ucs1lib_find_max_char inlined into _copy_characters 
_copy_characters
1434
                                             (Py_UCS1*)from_data + how_many);
1435
            if (max_char >= 128)
1436
                return -1;
1437
        }
1438
        memcpy((char*)to_data + to_kind * to_start,
1439
                  (char*)from_data + from_kind * from_start,
1440
                  to_kind * how_many);
1441
    }
1442
    else if (from_kind == PyUnicode_1BYTE_KIND
1443
             && to_kind == PyUnicode_2BYTE_KIND)
1444
    {
1445
        _PyUnicode_CONVERT_BYTES(
gvn
        
load of type i32 eliminated in favor of load 
_copy_characters
gvn
        
load of type i32 eliminated in favor of load 
_copy_characters
gvn
        
load of type i8 not eliminated because it is clobbered by store 
_copy_characters
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
_copy_characters
loop-vectorize
        
loop not vectorized 
_copy_characters
loop-vectorize
        
vectorized loop (vectorization width: 8, interleaved count: 2) 
_copy_characters
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
_copy_characters
1446
            Py_UCS1, Py_UCS2,
1447
            PyUnicode_1BYTE_DATA(from) + from_start,
1448
            PyUnicode_1BYTE_DATA(from) + from_start + how_many,
1449
            PyUnicode_2BYTE_DATA(to) + to_start
1450
            );
1451
    }
1452
    else if (from_kind == PyUnicode_1BYTE_KIND
1453
             && to_kind == PyUnicode_4BYTE_KIND)
1454
    {
1455
        _PyUnicode_CONVERT_BYTES(
gvn
        
load of type i32 eliminated in favor of load 
_copy_characters
gvn
        
load of type i32 eliminated in favor of load 
_copy_characters
gvn
        
load of type i8 not eliminated because it is clobbered by store 
_copy_characters
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
_copy_characters
loop-vectorize
        
loop not vectorized 
_copy_characters
loop-vectorize
        
vectorized loop (vectorization width: 4, interleaved count: 2) 
_copy_characters
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
_copy_characters
1456
            Py_UCS1, Py_UCS4,
1457
            PyUnicode_1BYTE_DATA(from) + from_start,
1458
            PyUnicode_1BYTE_DATA(from) + from_start + how_many,
1459
            PyUnicode_4BYTE_DATA(to) + to_start
1460
            );
1461
    }
1462
    else if (from_kind == PyUnicode_2BYTE_KIND
1463
             && to_kind == PyUnicode_4BYTE_KIND)
1464
    {
1465
        _PyUnicode_CONVERT_BYTES(
gvn
        
load of type i32 eliminated in favor of load 
_copy_characters
gvn
        
load of type i32 eliminated in favor of load 
_copy_characters
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
_copy_characters
loop-vectorize
        
loop not vectorized 
_copy_characters
1466
            Py_UCS2, Py_UCS4,
1467
            PyUnicode_2BYTE_DATA(from) + from_start,
1468
            PyUnicode_2BYTE_DATA(from) + from_start + how_many,
1469
            PyUnicode_4BYTE_DATA(to) + to_start
1470
            );
1471
    }
1472
    else {
1473
        assert (PyUnicode_MAX_CHAR_VALUE(from) > PyUnicode_MAX_CHAR_VALUE(to));
1474
1475
        if (!check_maxchar) {
1476
            if (from_kind == PyUnicode_2BYTE_KIND
1477
                && to_kind == PyUnicode_1BYTE_KIND)
1478
            {
1479
                _PyUnicode_CONVERT_BYTES(
gvn
                
load of type i32 eliminated in favor of load 
_copy_characters
gvn
                
load of type i32 eliminated in favor of load 
_copy_characters
gvn
                
load of type i16 not eliminated because it is clobbered by store 
_copy_characters
loop-vectorize
                
loop not vectorized: could not determine number of loop iterations 
_copy_characters
loop-vectorize
                
loop not vectorized 
_copy_characters
1480
                    Py_UCS2, Py_UCS1,
1481
                    PyUnicode_2BYTE_DATA(from) + from_start,
1482
                    PyUnicode_2BYTE_DATA(from) + from_start + how_many,
1483
                    PyUnicode_1BYTE_DATA(to) + to_start
1484
                    );
1485
            }
1486
            else if (from_kind == PyUnicode_4BYTE_KIND
1487
                     && to_kind == PyUnicode_1BYTE_KIND)
1488
            {
1489
                _PyUnicode_CONVERT_BYTES(
gvn
                
load of type i32 eliminated in favor of load 
_copy_characters
gvn
                
load of type i32 eliminated in favor of load 
_copy_characters
gvn
                
load of type i32 not eliminated because it is clobbered by store 
_copy_characters
loop-vectorize
                
loop not vectorized: could not determine number of loop iterations 
_copy_characters
loop-vectorize
                
loop not vectorized 
_copy_characters
1490
                    Py_UCS4, Py_UCS1,
1491
                    PyUnicode_4BYTE_DATA(from) + from_start,
1492
                    PyUnicode_4BYTE_DATA(from) + from_start + how_many,
1493
                    PyUnicode_1BYTE_DATA(to) + to_start
1494
                    );
1495
            }
1496
            else if (from_kind == PyUnicode_4BYTE_KIND
1497
                     && to_kind == PyUnicode_2BYTE_KIND)
1498
            {
1499
                _PyUnicode_CONVERT_BYTES(
gvn
                
load of type i32 eliminated in favor of load 
_copy_characters
gvn
                
load of type i32 eliminated in favor of load 
_copy_characters
loop-vectorize
                
loop not vectorized: could not determine number of loop iterations 
_copy_characters
loop-vectorize
                
loop not vectorized 
_copy_characters
1500
                    Py_UCS4, Py_UCS2,
1501
                    PyUnicode_4BYTE_DATA(from) + from_start,
1502
                    PyUnicode_4BYTE_DATA(from) + from_start + how_many,
1503
                    PyUnicode_2BYTE_DATA(to) + to_start
1504
                    );
1505
            }
1506
            else {
1507
                assert(0);
1508
                return -1;
1509
            }
1510
        }
1511
        else {
1512
            const Py_UCS4 to_maxchar = PyUnicode_MAX_CHAR_VALUE(to);
gvn
                                       
load of type i32 eliminated in favor of load 
_copy_characters
1513
            Py_UCS4 ch;
1514
            Py_ssize_t i;
1515
1516
            for (i=0; i < how_many; i++) {
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
_copy_characters
loop-vectorize
            
loop not vectorized 
_copy_characters
1517
                ch = PyUnicode_READ(from_kind, from_data, from_start + i);
licm
                     
hosting bitcast 
_copy_characters
1518
                if (ch > to_maxchar)
1519
                    return -1;
1520
                PyUnicode_WRITE(to_kind, to_data, to_start + i, ch);
licm
                
hosting trunc 
_copy_characters
licm
                
hosting bitcast 
_copy_characters
licm
                
hosting icmp 
_copy_characters
1521
            }
1522
        }
1523
    }
1524
    return 0;
1525
}
1526
1527
void
1528
_PyUnicode_FastCopyCharacters(
1529
    PyObject *to, Py_ssize_t to_start,
1530
    PyObject *from, Py_ssize_t from_start, Py_ssize_t how_many)
1531
{
1532
    (void)_copy_characters(to, to_start, from, from_start, how_many, 0);
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
_PyUnicode_FastCopyCharacters
inline
          
_copy_characters will not be inlined into _PyUnicode_FastCopyCharacters 
_PyUnicode_FastCopyCharacters
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
resize_copy
inline
          
_copy_characters will not be inlined into resize_copy 
resize_copy
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
unicode_resize
inline
          
_copy_characters will not be inlined into unicode_resize 
unicode_resize
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
_PyUnicodeWriter_PrepareInternal
inline
          
_copy_characters will not be inlined into _PyUnicodeWriter_PrepareInternal 
_PyUnicodeWriter_PrepareInternal
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
_PyUnicodeWriter_WriteStr
inline
          
_copy_characters will not be inlined into _PyUnicodeWriter_WriteStr 
_PyUnicodeWriter_WriteStr
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
unicode_fromformat_write_str
inline
          
_copy_characters will not be inlined into unicode_fromformat_write_str 
unicode_fromformat_write_str
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
fixup
inline
          
_copy_characters will not be inlined into fixup 
fixup
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
_PyUnicode_TransformDecimalAndSpaceToASCII
inline
          
_copy_characters will not be inlined into _PyUnicode_TransformDecimalAndSpaceToASCII 
_PyUnicode_TransformDecimalAndSpaceToASCII
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
_PyUnicode_JoinArray
inline
          
_copy_characters will not be inlined into _PyUnicode_JoinArray 
_PyUnicode_JoinArray
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
PyUnicode_Concat
inline
          
_copy_characters will not be inlined into PyUnicode_Concat 
PyUnicode_Concat
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
PyUnicode_Append
inline
          
_copy_characters will not be inlined into PyUnicode_Append 
PyUnicode_Append
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
unicode_adjust_maxchar
inline
          
_copy_characters will not be inlined into unicode_adjust_maxchar 
unicode_adjust_maxchar
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
replace
inline
          
_copy_characters will not be inlined into replace 
replace
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
_PyUnicodeWriter_WriteSubstring
inline
          
_copy_characters will not be inlined into _PyUnicodeWriter_WriteSubstring 
_PyUnicodeWriter_WriteSubstring
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
unicode_format_arg_output
inline
          
_copy_characters will not be inlined into unicode_format_arg_output 
unicode_format_arg_output
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
unicode_format_arg
inline
          
_copy_characters will not be inlined into unicode_format_arg 
unicode_format_arg
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
PyUnicode_Format
inline
          
_copy_characters will not be inlined into PyUnicode_Format 
PyUnicode_Format
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
unicode_repr
inline
          
_copy_characters will not be inlined into unicode_repr 
unicode_repr
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
pad
inline
          
_copy_characters will not be inlined into pad 
pad
1533
}
1534
1535
Py_ssize_t
1536
PyUnicode_CopyCharacters(PyObject *to, Py_ssize_t to_start,
1537
                         PyObject *from, Py_ssize_t from_start,
1538
                         Py_ssize_t how_many)
1539
{
1540
    int err;
1541
1542
    if (!PyUnicode_Check(from) || !PyUnicode_Check(to)) {
1543
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into PyUnicode_CopyCharacters because its definition is unavailable 
PyUnicode_CopyCharacters
1544
        return -1;
1545
    }
1546
1547
    if (PyUnicode_READY(from) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_CopyCharacters
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_CopyCharacters 
PyUnicode_CopyCharacters
1548
        return -1;
1549
    if (PyUnicode_READY(to) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_CopyCharacters
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_CopyCharacters 
PyUnicode_CopyCharacters
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
1550
        return -1;
1551
1552
    if ((size_t)from_start > (size_t)PyUnicode_GET_LENGTH(from)) {
gvn
                                     
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
                                     
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
1553
        PyErr_SetString(PyExc_IndexError, "string index out of range");
inline
        
PyErr_SetString will not be inlined into PyUnicode_CopyCharacters because its definition is unavailable 
PyUnicode_CopyCharacters
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
1554
        return -1;
1555
    }
1556
    if ((size_t)to_start > (size_t)PyUnicode_GET_LENGTH(to)) {
gvn
                                   
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
                                   
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
1557
        PyErr_SetString(PyExc_IndexError, "string index out of range");
inline
        
PyErr_SetString will not be inlined into PyUnicode_CopyCharacters because its definition is unavailable 
PyUnicode_CopyCharacters
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
1558
        return -1;
1559
    }
1560
    if (how_many < 0) {
1561
        PyErr_SetString(PyExc_SystemError, "how_many cannot be negative");
inline
        
PyErr_SetString will not be inlined into PyUnicode_CopyCharacters because its definition is unavailable 
PyUnicode_CopyCharacters
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
1562
        return -1;
1563
    }
1564
    how_many = Py_MIN(PyUnicode_GET_LENGTH(from)-from_start, how_many);
1565
    if (to_start + how_many > PyUnicode_GET_LENGTH(to)) {
1566
        PyErr_Format(PyExc_SystemError,
inline
        
PyErr_Format will not be inlined into PyUnicode_CopyCharacters because its definition is unavailable 
PyUnicode_CopyCharacters
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
1567
                     "Cannot write %zi characters at %zi "
1568
                     "in a string of %zi characters",
1569
                     how_many, to_start, PyUnicode_GET_LENGTH(to));
1570
        return -1;
1571
    }
1572
1573
    if (how_many == 0)
1574
        return 0;
1575
1576
    if (unicode_check_modifiable(to))
inline
        
unicode_check_modifiable can be inlined into PyUnicode_CopyCharacters with cost=75 (threshold=250) 
PyUnicode_CopyCharacters
inline
        
unicode_check_modifiable inlined into PyUnicode_CopyCharacters 
PyUnicode_CopyCharacters
1577
        return -1;
1578
1579
    err = _copy_characters(to, to_start, from, from_start, how_many, 1);
inline
          
_copy_characters too costly to inline (cost=630, threshold=625) 
PyUnicode_CopyCharacters
inline
          
_copy_characters will not be inlined into PyUnicode_CopyCharacters 
PyUnicode_CopyCharacters
1580
    if (err) {
1581
        PyErr_Format(PyExc_SystemError,
inline
        
PyErr_Format will not be inlined into PyUnicode_CopyCharacters because its definition is unavailable 
PyUnicode_CopyCharacters
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
1582
                     "Cannot copy %s characters "
1583
                     "into a string of %s characters",
1584
                     unicode_kind_name(from),
inline
                     
unicode_kind_name can be inlined into PyUnicode_CopyCharacters with cost=75 (threshold=250) 
PyUnicode_CopyCharacters
inline
                     
unicode_kind_name inlined into PyUnicode_CopyCharacters 
PyUnicode_CopyCharacters
1585
                     unicode_kind_name(to));
inline
                     
unicode_kind_name can be inlined into PyUnicode_CopyCharacters with cost=-14925 (threshold=250) 
PyUnicode_CopyCharacters
inline
                     
unicode_kind_name inlined into PyUnicode_CopyCharacters 
PyUnicode_CopyCharacters
1586
        return -1;
1587
    }
1588
    return how_many;
1589
}
1590
1591
/* Find the maximum code point and count the number of surrogate pairs so a
1592
   correct string length can be computed before converting a string to UCS4.
1593
   This function counts single surrogates as a character and not as a pair.
1594
1595
   Return 0 on success, or -1 on error. */
1596
static int
1597
find_maxchar_surrogates(const wchar_t *begin, const wchar_t *end,
1598
                        Py_UCS4 *maxchar, Py_ssize_t *num_surrogates)
1599
{
1600
    const wchar_t *iter;
1601
    Py_UCS4 ch;
1602
1603
    assert(num_surrogates != NULL && maxchar != NULL);
1604
    *num_surrogates = 0;
1605
    *maxchar = 0;
1606
1607
    for (iter = begin; iter < end; ) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_Ready
loop-vectorize
    
loop not vectorized 
_PyUnicode_Ready
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_FromUnicode
loop-vectorize
    
loop not vectorized 
PyUnicode_FromUnicode
1608
#if SIZEOF_WCHAR_T == 2
1609
        if (Py_UNICODE_IS_HIGH_SURROGATE(iter[0])
1610
            && (iter+1) < end
1611
            && Py_UNICODE_IS_LOW_SURROGATE(iter[1]))
1612
        {
1613
            ch = Py_UNICODE_JOIN_SURROGATES(iter[0], iter[1]);
1614
            ++(*num_surrogates);
1615
            iter += 2;
1616
        }
1617
        else
1618
#endif
1619
        {
1620
            ch = *iter;
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
find_maxchar_surrogates
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
find_maxchar_surrogates
1621
            iter++;
1622
        }
1623
        if (ch > *maxchar) {
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
find_maxchar_surrogates
gvn
                 
load of type i32 eliminated in favor of phi 
find_maxchar_surrogates
1624
            *maxchar = ch;
1625
            if (*maxchar > MAX_UNICODE) {
1626
                PyErr_Format(PyExc_ValueError,
inline
                
PyErr_Format will not be inlined into find_maxchar_surrogates because its definition is unavailable 
find_maxchar_surrogates
1627
                             "character U+%x is not in range [U+0000; U+10ffff]",
1628
                             ch);
1629
                return -1;
1630
            }
1631
        }
1632
    }
1633
    return 0;
1634
}
1635
1636
int
1637
_PyUnicode_Ready(PyObject *unicode)
1638
{
1639
    wchar_t *end;
1640
    Py_UCS4 maxchar = 0;
1641
    Py_ssize_t num_surrogates;
1642
#if SIZEOF_WCHAR_T == 2
1643
    Py_ssize_t length_wo_surrogates;
1644
#endif
1645
1646
    /* _PyUnicode_Ready() is only intended for old-style API usage where
1647
       strings were created using _PyObject_New() and where no canonical
1648
       representation (the str field) has been set yet aka strings
1649
       which are not yet ready. */
1650
    assert(_PyUnicode_CHECK(unicode));
1651
    assert(_PyUnicode_KIND(unicode) == PyUnicode_WCHAR_KIND);
1652
    assert(_PyUnicode_WSTR(unicode) != NULL);
1653
    assert(_PyUnicode_DATA_ANY(unicode) == NULL);
1654
    assert(_PyUnicode_UTF8(unicode) == NULL);
1655
    /* Actually, it should neither be interned nor be anything else: */
1656
    assert(_PyUnicode_STATE(unicode).interned == SSTATE_NOT_INTERNED);
1657
1658
    end = _PyUnicode_WSTR(unicode) + _PyUnicode_WSTR_LENGTH(unicode);
1659
    if (find_maxchar_surrogates(_PyUnicode_WSTR(unicode), end,
inline
        
find_maxchar_surrogates can be inlined into _PyUnicode_Ready with cost=45 (threshold=250) 
_PyUnicode_Ready
inline
        
find_maxchar_surrogates inlined into _PyUnicode_Ready 
_PyUnicode_Ready
1660
                                &maxchar, &num_surrogates) == -1)
1661
        return -1;
1662
1663
    if (maxchar < 256) {
1664
        _PyUnicode_DATA_ANY(unicode) = PyObject_MALLOC(_PyUnicode_WSTR_LENGTH(unicode) + 1);
inline
                                       
PyObject_Malloc will not be inlined into _PyUnicode_Ready because its definition is unavailable 
_PyUnicode_Ready
gvn
                                                       
load of type i64 eliminated in favor of load 
_PyUnicode_Ready
1665
        if (!_PyUnicode_DATA_ANY(unicode)) {
1666
            PyErr_NoMemory();
inline
            
PyErr_NoMemory will not be inlined into _PyUnicode_Ready because its definition is unavailable 
_PyUnicode_Ready
1667
            return -1;
1668
        }
1669
        _PyUnicode_CONVERT_BYTES(wchar_t, unsigned char,
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_Ready
gvn
        
load of type i32* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_Ready
gvn
        
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_Ready
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
_PyUnicode_Ready
loop-vectorize
        
loop not vectorized 
_PyUnicode_Ready
1670
                                _PyUnicode_WSTR(unicode), end,
1671
                                PyUnicode_1BYTE_DATA(unicode));
1672
        PyUnicode_1BYTE_DATA(unicode)[_PyUnicode_WSTR_LENGTH(unicode)] = '\0';
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by store 
_PyUnicode_Ready
gvn
        
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_Ready
gvn
                                      
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_Ready
gvn
                                      
load of type i64 not eliminated in favor of load because it is clobbered by store 
_PyUnicode_Ready
1673
        _PyUnicode_LENGTH(unicode) = _PyUnicode_WSTR_LENGTH(unicode);
gvn
                                     
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_Ready
1674
        _PyUnicode_STATE(unicode).kind = PyUnicode_1BYTE_KIND;
gvn
                                       
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_Ready
1675
        if (maxchar < 128) {
1676
            _PyUnicode_STATE(unicode).ascii = 1;
1677
            _PyUnicode_UTF8(unicode) = _PyUnicode_DATA_ANY(unicode);
gvn
                                       
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_Ready
1678
            _PyUnicode_UTF8_LENGTH(unicode) = _PyUnicode_WSTR_LENGTH(unicode);
1679
        }
1680
        else {
1681
            _PyUnicode_STATE(unicode).ascii = 0;
1682
            _PyUnicode_UTF8(unicode) = NULL;
1683
            _PyUnicode_UTF8_LENGTH(unicode) = 0;
1684
        }
1685
        PyObject_FREE(_PyUnicode_WSTR(unicode));
inline
        
PyObject_Free will not be inlined into _PyUnicode_Ready because its definition is unavailable 
_PyUnicode_Ready
gvn
                      
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_Ready
1686
        _PyUnicode_WSTR(unicode) = NULL;
1687
        _PyUnicode_WSTR_LENGTH(unicode) = 0;
1688
    }
1689
    /* In this case we might have to convert down from 4-byte native
1690
       wchar_t to 2-byte unicode. */
1691
    else if (maxchar < 65536) {
1692
        assert(num_surrogates == 0 &&
1693
               "FindMaxCharAndNumSurrogatePairs() messed up");
1694
1695
#if SIZEOF_WCHAR_T == 2
1696
        /* We can share representations and are done. */
1697
        _PyUnicode_DATA_ANY(unicode) = _PyUnicode_WSTR(unicode);
1698
        PyUnicode_2BYTE_DATA(unicode)[_PyUnicode_WSTR_LENGTH(unicode)] = '\0';
1699
        _PyUnicode_LENGTH(unicode) = _PyUnicode_WSTR_LENGTH(unicode);
1700
        _PyUnicode_STATE(unicode).kind = PyUnicode_2BYTE_KIND;
1701
        _PyUnicode_UTF8(unicode) = NULL;
1702
        _PyUnicode_UTF8_LENGTH(unicode) = 0;
1703
#else
1704
        /* sizeof(wchar_t) == 4 */
1705
        _PyUnicode_DATA_ANY(unicode) = PyObject_MALLOC(
inline
                                       
PyObject_Malloc will not be inlined into _PyUnicode_Ready because its definition is unavailable 
_PyUnicode_Ready
1706
            2 * (_PyUnicode_WSTR_LENGTH(unicode) + 1));
gvn
                 
load of type i64 eliminated in favor of load 
_PyUnicode_Ready
1707
        if (!_PyUnicode_DATA_ANY(unicode)) {
1708
            PyErr_NoMemory();
inline
            
PyErr_NoMemory will not be inlined into _PyUnicode_Ready because its definition is unavailable 
_PyUnicode_Ready
1709
            return -1;
1710
        }
1711
        _PyUnicode_CONVERT_BYTES(wchar_t, Py_UCS2,
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_Ready
gvn
        
load of type i32* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_Ready
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
_PyUnicode_Ready
loop-vectorize
        
loop not vectorized 
_PyUnicode_Ready
1712
                                _PyUnicode_WSTR(unicode), end,
1713
                                PyUnicode_2BYTE_DATA(unicode));
1714
        PyUnicode_2BYTE_DATA(unicode)[_PyUnicode_WSTR_LENGTH(unicode)] = '\0';
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by store 
_PyUnicode_Ready
gvn
        
load of type i8* eliminated in favor of call 
_PyUnicode_Ready
gvn
                                      
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_Ready
1715
        _PyUnicode_LENGTH(unicode) = _PyUnicode_WSTR_LENGTH(unicode);
1716
        _PyUnicode_STATE(unicode).kind = PyUnicode_2BYTE_KIND;
gvn
                                       
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_Ready
1717
        _PyUnicode_UTF8(unicode) = NULL;
1718
        _PyUnicode_UTF8_LENGTH(unicode) = 0;
1719
        PyObject_FREE(_PyUnicode_WSTR(unicode));
inline
        
PyObject_Free will not be inlined into _PyUnicode_Ready because its definition is unavailable 
_PyUnicode_Ready
gvn
                      
load of type i8* eliminated in favor of inttoptr 
_PyUnicode_Ready
1720
        _PyUnicode_WSTR(unicode) = NULL;
1721
        _PyUnicode_WSTR_LENGTH(unicode) = 0;
1722
#endif
1723
    }
1724
    /* maxchar exeeds 16 bit, wee need 4 bytes for unicode characters */
1725
    else {
1726
#if SIZEOF_WCHAR_T == 2
1727
        /* in case the native representation is 2-bytes, we need to allocate a
1728
           new normalized 4-byte version. */
1729
        length_wo_surrogates = _PyUnicode_WSTR_LENGTH(unicode) - num_surrogates;
1730
        if (length_wo_surrogates > PY_SSIZE_T_MAX / 4 - 1) {
1731
            PyErr_NoMemory();
1732
            return -1;
1733
        }
1734
        _PyUnicode_DATA_ANY(unicode) = PyObject_MALLOC(4 * (length_wo_surrogates + 1));
1735
        if (!_PyUnicode_DATA_ANY(unicode)) {
1736
            PyErr_NoMemory();
1737
            return -1;
1738
        }
1739
        _PyUnicode_LENGTH(unicode) = length_wo_surrogates;
1740
        _PyUnicode_STATE(unicode).kind = PyUnicode_4BYTE_KIND;
1741
        _PyUnicode_UTF8(unicode) = NULL;
1742
        _PyUnicode_UTF8_LENGTH(unicode) = 0;
1743
        /* unicode_convert_wchar_to_ucs4() requires a ready string */
1744
        _PyUnicode_STATE(unicode).ready = 1;
1745
        unicode_convert_wchar_to_ucs4(_PyUnicode_WSTR(unicode), end, unicode);
1746
        PyObject_FREE(_PyUnicode_WSTR(unicode));
1747
        _PyUnicode_WSTR(unicode) = NULL;
1748
        _PyUnicode_WSTR_LENGTH(unicode) = 0;
1749
#else
1750
        assert(num_surrogates == 0);
1751
1752
        _PyUnicode_DATA_ANY(unicode) = _PyUnicode_WSTR(unicode);
gvn
                                       
load of type i64 eliminated in favor of ptrtoint 
_PyUnicode_Ready
1753
        _PyUnicode_LENGTH(unicode) = _PyUnicode_WSTR_LENGTH(unicode);
gvn
                                     
load of type i64 eliminated in favor of load 
_PyUnicode_Ready
1754
        _PyUnicode_UTF8(unicode) = NULL;
1755
        _PyUnicode_UTF8_LENGTH(unicode) = 0;
1756
        _PyUnicode_STATE(unicode).kind = PyUnicode_4BYTE_KIND;
1757
#endif
1758
        PyUnicode_4BYTE_DATA(unicode)[_PyUnicode_LENGTH(unicode)] = '\0';
gvn
        
load of type i8* eliminated in favor of inttoptr 
_PyUnicode_Ready
gvn
                                      
load of type i64 eliminated in favor of load 
_PyUnicode_Ready
1759
    }
1760
    _PyUnicode_STATE(unicode).ready = 1;
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_Ready
gvn
                                    
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_Ready
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_Ready
1761
    assert(_PyUnicode_CheckConsistency(unicode, 1));
1762
    return 0;
1763
}
1764
1765
static void
1766
unicode_dealloc(PyObject *unicode)
1767
{
1768
    switch (PyUnicode_CHECK_INTERNED(unicode)) {
1769
    case SSTATE_NOT_INTERNED:
1770
        break;
1771
1772
    case SSTATE_INTERNED_MORTAL:
1773
        /* revive dead object temporarily for DelItem */
1774
        Py_REFCNT(unicode) = 3;
1775
        if (PyDict_DelItem(interned, unicode) != 0)
inline
            
PyDict_DelItem will not be inlined into unicode_dealloc because its definition is unavailable 
unicode_dealloc
1776
            Py_FatalError(
inline
            
Py_FatalError will not be inlined into unicode_dealloc because its definition is unavailable 
unicode_dealloc
1777
                "deletion of interned string failed");
1778
        break;
1779
1780
    case SSTATE_INTERNED_IMMORTAL:
1781
        Py_FatalError("Immortal interned string died.");
inline
        
Py_FatalError will not be inlined into unicode_dealloc because its definition is unavailable 
unicode_dealloc
1782
1783
    default:
1784
        Py_FatalError("Inconsistent interned string state.");
inline
        
Py_FatalError will not be inlined into unicode_dealloc because its definition is unavailable 
unicode_dealloc
1785
    }
1786
1787
    if (_PyUnicode_HAS_WSTR_MEMORY(unicode))
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_dealloc
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_dealloc
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_dealloc
1788
        PyObject_DEL(_PyUnicode_WSTR(unicode));
inline
        
PyObject_Free will not be inlined into unicode_dealloc because its definition is unavailable 
unicode_dealloc
gvn
                     
load of type i8* eliminated in favor of inttoptr 
unicode_dealloc
1789
    if (_PyUnicode_HAS_UTF8_MEMORY(unicode))
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_dealloc
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_dealloc
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_dealloc
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_dealloc
1790
        PyObject_DEL(_PyUnicode_UTF8(unicode));
inline
        
PyObject_Free will not be inlined into unicode_dealloc because its definition is unavailable 
unicode_dealloc
gvn
                     
load of type i8* eliminated in favor of load 
unicode_dealloc
1791
    if (!PyUnicode_IS_COMPACT(unicode) && _PyUnicode_DATA_ANY(unicode))
gvn
         
load of type i32 not eliminated because it is clobbered by call 
unicode_dealloc
gvn
         
load eliminated by PRE 
unicode_dealloc
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
unicode_dealloc
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
unicode_dealloc
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
unicode_dealloc
1792
        PyObject_DEL(_PyUnicode_DATA_ANY(unicode));
inline
        
PyObject_Free will not be inlined into unicode_dealloc because its definition is unavailable 
unicode_dealloc
1793
1794
    Py_TYPE(unicode)->tp_free(unicode);
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_dealloc
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_dealloc
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_dealloc
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_dealloc
1795
}
1796
1797
#ifdef Py_DEBUG
1798
static int
1799
unicode_is_singleton(PyObject *unicode)
1800
{
1801
    PyASCIIObject *ascii = (PyASCIIObject *)unicode;
1802
    if (unicode == unicode_empty)
1803
        return 1;
1804
    if (ascii->state.kind != PyUnicode_WCHAR_KIND && ascii->length == 1)
1805
    {
1806
        Py_UCS4 ch = PyUnicode_READ_CHAR(unicode, 0);
1807
        if (ch < 256 && unicode_latin1[ch] == unicode)
1808
            return 1;
1809
    }
1810
    return 0;
1811
}
1812
#endif
1813
1814
static int
1815
unicode_modifiable(PyObject *unicode)
1816
{
1817
    assert(_PyUnicode_CHECK(unicode));
1818
    if (Py_REFCNT(unicode) != 1)
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Fill
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Append
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Append
1819
        return 0;
1820
    if (_PyUnicode_HASH(unicode) != -1)
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Fill
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Append
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Append
1821
        return 0;
1822
    if (PyUnicode_CHECK_INTERNED(unicode))
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
        
load of type i32 eliminated in favor of load 
unicode_resize
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Fill
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
1823
        return 0;
1824
    if (!PyUnicode_CheckExact(unicode))
gvn
         
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
         
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_CopyCharacters
gvn
         
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Fill
gvn
         
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
         
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
1825
        return 0;
1826
#ifdef Py_DEBUG
1827
    /* singleton refcount is greater than 1 */
1828
    assert(!unicode_is_singleton(unicode));
1829
#endif
1830
    return 1;
1831
}
1832
1833
static int
1834
unicode_resize(PyObject **p_unicode, Py_ssize_t length)
1835
{
1836
    PyObject *unicode;
1837
    Py_ssize_t old_length;
1838
1839
    assert(p_unicode != NULL);
1840
    unicode = *p_unicode;
1841
1842
    assert(unicode != NULL);
1843
    assert(PyUnicode_Check(unicode));
1844
    assert(0 <= length);
1845
1846
    if (_PyUnicode_KIND(unicode) == PyUnicode_WCHAR_KIND)
1847
        old_length = PyUnicode_WSTR_LENGTH(unicode);
1848
    else
1849
        old_length = PyUnicode_GET_LENGTH(unicode);
1850
    if (old_length == length)
1851
        return 0;
1852
1853
    if (length == 0) {
1854
        _Py_INCREF_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
unicode_resize
inline
        
PyUnicode_New will not be inlined into unicode_resize 
unicode_resize
1855
        if (!unicode_empty)
1856
            return -1;
1857
        Py_SETREF(*p_unicode, unicode_empty);
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_resize
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_resize
1858
        return 0;
1859
    }
1860
1861
    if (!unicode_modifiable(unicode)) {
inline
         
unicode_modifiable can be inlined into unicode_resize with cost=25 (threshold=250) 
unicode_resize
inline
         
unicode_modifiable inlined into unicode_resize 
unicode_resize
1862
        PyObject *copy = resize_copy(unicode, length);
inline
                         
resize_copy can be inlined into unicode_resize with cost=-14710 (threshold=250) 
unicode_resize
inline
                         
resize_copy inlined into unicode_resize 
unicode_resize
1863
        if (copy == NULL)
1864
            return -1;
1865
        Py_SETREF(*p_unicode, copy);
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_resize
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_resize
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_resize
1866
        return 0;
1867
    }
1868
1869
    if (PyUnicode_IS_COMPACT(unicode)) {
gvn
        
load of type i32 eliminated in favor of load 
unicode_resize
1870
        PyObject *new_unicode = resize_compact(unicode, length);
inline
                                
resize_compact too costly to inline (cost=630, threshold=625) 
unicode_resize
inline
                                
resize_compact will not be inlined into unicode_resize 
unicode_resize
1871
        if (new_unicode == NULL)
1872
            return -1;
1873
        *p_unicode = new_unicode;
1874
        return 0;
1875
    }
1876
    return resize_inplace(unicode, length);
inline
           
resize_inplace can be inlined into unicode_resize with cost=-14455 (threshold=250) 
unicode_resize
inline
           
resize_inplace inlined into unicode_resize 
unicode_resize
1877
}
1878
1879
int
1880
PyUnicode_Resize(PyObject **p_unicode, Py_ssize_t length)
1881
{
1882
    PyObject *unicode;
1883
    if (p_unicode == NULL) {
1884
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into PyUnicode_Resize because its definition is unavailable 
PyUnicode_Resize
1885
        return -1;
1886
    }
1887
    unicode = *p_unicode;
gvn
              
load of type %struct._object* eliminated in favor of load 
_PyUnicode_FormatLong
1888
    if (unicode == NULL || !PyUnicode_Check(unicode) || length < 0)
gvn
                            
load of type %struct._typeobject* eliminated in favor of load 
_PyUnicode_FormatLong
gvn
                            
load of type i64 eliminated in favor of load 
_PyUnicode_FormatLong
1889
    {
1890
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into PyUnicode_Resize because its definition is unavailable 
PyUnicode_Resize
1891
        return -1;
1892
    }
1893
    return unicode_resize(p_unicode, length);
inline
           
unicode_resize too costly to inline (cost=630, threshold=625) 
PyUnicode_Resize
inline
           
unicode_resize will not be inlined into PyUnicode_Resize 
PyUnicode_Resize
inline
           
unicode_resize too costly to inline (cost=630, threshold=625) 
_PyUnicode_FormatLong
inline
           
unicode_resize will not be inlined into _PyUnicode_FormatLong 
_PyUnicode_FormatLong
1894
}
1895
1896
/* Copy an ASCII or latin1 char* string into a Python Unicode string.
1897
1898
   WARNING: The function doesn't copy the terminating null character and
1899
   doesn't check the maximum character (may write a latin1 character in an
1900
   ASCII string). */
1901
static void
1902
unicode_write_cstr(PyObject *unicode, Py_ssize_t index,
1903
                   const char *str, Py_ssize_t len)
1904
{
1905
    enum PyUnicode_Kind kind = PyUnicode_KIND(unicode);
1906
    void *data = PyUnicode_DATA(unicode);
1907
    const char *end = str + len;
1908
1909
    switch (kind) {
1910
    case PyUnicode_1BYTE_KIND: {
1911
        assert(index + len <= PyUnicode_GET_LENGTH(unicode));
1912
#ifdef Py_DEBUG
1913
        if (PyUnicode_IS_ASCII(unicode)) {
1914
            Py_UCS4 maxchar = ucs1lib_find_max_char(
1915
                (const Py_UCS1*)str,
1916
                (const Py_UCS1*)str + len);
1917
            assert(maxchar < 128);
1918
        }
1919
#endif
1920
        memcpy((char *) data + index, str, len);
1921
        break;
1922
    }
1923
    case PyUnicode_2BYTE_KIND: {
1924
        Py_UCS2 *start = (Py_UCS2 *)data + index;
1925
        Py_UCS2 *ucs2 = start;
1926
        assert(index <= PyUnicode_GET_LENGTH(unicode));
1927
1928
        for (; str < end; ++ucs2, ++str)
loop-vectorize
        
vectorized loop (vectorization width: 8, interleaved count: 2) 
_PyUnicodeWriter_WriteLatin1String
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
_PyUnicodeWriter_WriteLatin1String
1929
            *ucs2 = (Py_UCS2)*str;
gvn
                             
load of type i8 not eliminated because it is clobbered by store 
unicode_write_cstr
gvn
                             
load of type i8 not eliminated because it is clobbered by store 
_PyUnicodeWriter_WriteLatin1String
gvn
                             
load of type i8 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteLatin1String
1930
1931
        assert((ucs2 - start) <= PyUnicode_GET_LENGTH(unicode));
1932
        break;
1933
    }
1934
    default: {
1935
        Py_UCS4 *start = (Py_UCS4 *)data + index;
1936
        Py_UCS4 *ucs4 = start;
1937
        assert(kind == PyUnicode_4BYTE_KIND);
1938
        assert(index <= PyUnicode_GET_LENGTH(unicode));
1939
1940
        for (; str < end; ++ucs4, ++str)
loop-vectorize
        
vectorized loop (vectorization width: 4, interleaved count: 2) 
_PyUnicodeWriter_WriteLatin1String
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
_PyUnicodeWriter_WriteLatin1String
1941
            *ucs4 = (Py_UCS4)*str;
gvn
                             
load of type i8 not eliminated because it is clobbered by store 
unicode_write_cstr
gvn
                             
load of type i8 not eliminated because it is clobbered by store 
_PyUnicodeWriter_WriteLatin1String
gvn
                             
load of type i8 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteLatin1String
1942
1943
        assert((ucs4 - start) <= PyUnicode_GET_LENGTH(unicode));
1944
    }
1945
    }
1946
}
1947
1948
static PyObject*
1949
get_latin1_char(unsigned char ch)
1950
{
1951
    PyObject *unicode = unicode_latin1[ch];
1952
    if (!unicode) {
1953
        unicode = PyUnicode_New(1, ch);
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
get_latin1_char
inline
                  
PyUnicode_New will not be inlined into get_latin1_char 
get_latin1_char
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
unicode_result_wchar
inline
                  
PyUnicode_New will not be inlined into unicode_result_wchar 
unicode_result_wchar
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
unicode_result
inline
                  
PyUnicode_New will not be inlined into unicode_result 
unicode_result
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
PyUnicode_FromUnicode
inline
                  
PyUnicode_New will not be inlined into PyUnicode_FromUnicode 
PyUnicode_FromUnicode
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
PyUnicode_DecodeUTF8Stateful
inline
                  
PyUnicode_New will not be inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
_PyUnicode_FromASCII
inline
                  
PyUnicode_New will not be inlined into _PyUnicode_FromASCII 
_PyUnicode_FromASCII
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
_PyUnicode_FromUCS1
inline
                  
PyUnicode_New will not be inlined into _PyUnicode_FromUCS1 
_PyUnicode_FromUCS1
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
_PyUnicode_FromUCS2
inline
                  
PyUnicode_New will not be inlined into _PyUnicode_FromUCS2 
_PyUnicode_FromUCS2
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
_PyUnicode_FromUCS4
inline
                  
PyUnicode_New will not be inlined into _PyUnicode_FromUCS4 
_PyUnicode_FromUCS4
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
_PyUnicodeWriter_WriteASCIIString
inline
                  
PyUnicode_New will not be inlined into _PyUnicodeWriter_WriteASCIIString 
_PyUnicodeWriter_WriteASCIIString
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
PyUnicode_FromOrdinal
inline
                  
PyUnicode_New will not be inlined into PyUnicode_FromOrdinal 
PyUnicode_FromOrdinal
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
PyUnicode_DecodeASCII
inline
                  
PyUnicode_New will not be inlined into PyUnicode_DecodeASCII 
PyUnicode_DecodeASCII
inline
                  
PyUnicode_New too costly to inline (cost=265, threshold=250) 
_PyUnicode_JoinArray
inline
                  
PyUnicode_New will not be inlined into _PyUnicode_JoinArray 
_PyUnicode_JoinArray
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
asciilib_splitlines
inline
                  
PyUnicode_New will not be inlined into asciilib_splitlines 
asciilib_splitlines
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
PyUnicode_Splitlines
inline
                  
PyUnicode_New will not be inlined into PyUnicode_Splitlines 
PyUnicode_Splitlines
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
PyUnicode_Substring
inline
                  
PyUnicode_New will not be inlined into PyUnicode_Substring 
PyUnicode_Substring
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
asciilib_split_whitespace
inline
                  
PyUnicode_New will not be inlined into asciilib_split_whitespace 
asciilib_split_whitespace
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
asciilib_split_char
inline
                  
PyUnicode_New will not be inlined into asciilib_split_char 
asciilib_split_char
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
asciilib_split
inline
                  
PyUnicode_New will not be inlined into asciilib_split 
asciilib_split
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
split
inline
                  
PyUnicode_New will not be inlined into split 
split
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
asciilib_partition
inline
                  
PyUnicode_New will not be inlined into asciilib_partition 
asciilib_partition
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
PyUnicode_Partition
inline
                  
PyUnicode_New will not be inlined into PyUnicode_Partition 
PyUnicode_Partition
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
asciilib_rpartition
inline
                  
PyUnicode_New will not be inlined into asciilib_rpartition 
asciilib_rpartition
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
PyUnicode_RPartition
inline
                  
PyUnicode_New will not be inlined into PyUnicode_RPartition 
PyUnicode_RPartition
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
asciilib_rsplit_whitespace
inline
                  
PyUnicode_New will not be inlined into asciilib_rsplit_whitespace 
asciilib_rsplit_whitespace
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
asciilib_rsplit_char
inline
                  
PyUnicode_New will not be inlined into asciilib_rsplit_char 
asciilib_rsplit_char
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
asciilib_rsplit
inline
                  
PyUnicode_New will not be inlined into asciilib_rsplit 
asciilib_rsplit
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
rsplit
inline
                  
PyUnicode_New will not be inlined into rsplit 
rsplit
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
_PyUnicode_FormatLong
inline
                  
PyUnicode_New will not be inlined into _PyUnicode_FormatLong 
_PyUnicode_FormatLong
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
formatfloat
inline
                  
PyUnicode_New will not be inlined into formatfloat 
formatfloat
inline
                  
PyUnicode_New too costly to inline (cost=350, threshold=250) 
unicode_getitem
inline
                  
PyUnicode_New will not be inlined into unicode_getitem 
unicode_getitem
1954
        if (!unicode)
1955
            return NULL;
1956
        PyUnicode_1BYTE_DATA(unicode)[0] = ch;
gvn
        
load of type i32 not eliminated because it is clobbered by call 
get_latin1_char
gvn
        
load of type i8* not eliminated because it is clobbered by call 
get_latin1_char
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_result_wchar
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_result_wchar
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_result
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_result
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromUnicode
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromUnicode
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_FromASCII
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromASCII
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_FromUCS1
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS1
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_FromUCS2
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS2
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_FromUCS4
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS4
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromOrdinal
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromOrdinal
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
        
load of type i32 not eliminated because it is clobbered by call 
asciilib_splitlines
gvn
        
load of type i8* not eliminated because it is clobbered by call 
asciilib_splitlines
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Splitlines
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Splitlines
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Substring
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Substring
gvn
        
load of type i32 not eliminated because it is clobbered by call 
asciilib_split_whitespace
gvn
        
load of type i8* not eliminated because it is clobbered by call 
asciilib_split_whitespace
gvn
        
load of type i32 not eliminated because it is clobbered by call 
asciilib_split_char
gvn
        
load of type i8* not eliminated because it is clobbered by call 
asciilib_split_char
gvn
        
load of type i32 not eliminated because it is clobbered by call 
asciilib_split
gvn
        
load of type i8* not eliminated because it is clobbered by call 
asciilib_split
gvn
        
load of type i32 not eliminated because it is clobbered by call 
split
gvn
        
load of type i8* not eliminated because it is clobbered by call 
split
gvn
        
load of type i32 not eliminated because it is clobbered by call 
asciilib_partition
gvn
        
load of type i8* not eliminated because it is clobbered by call 
asciilib_partition
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Partition
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Partition
gvn
        
load of type i32 not eliminated because it is clobbered by call 
asciilib_rpartition
gvn
        
load of type i8* not eliminated because it is clobbered by call 
asciilib_rpartition
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_RPartition
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_RPartition
gvn
        
load of type i32 not eliminated because it is clobbered by call 
asciilib_rsplit_whitespace
gvn
        
load of type i8* not eliminated because it is clobbered by call 
asciilib_rsplit_whitespace
gvn
        
load of type i32 not eliminated because it is clobbered by call 
asciilib_rsplit_char
gvn
        
load of type i8* not eliminated because it is clobbered by call 
asciilib_rsplit_char
gvn
        
load of type i32 not eliminated because it is clobbered by call 
asciilib_rsplit
gvn
        
load of type i8* not eliminated because it is clobbered by call 
asciilib_rsplit
gvn
        
load of type i32 not eliminated because it is clobbered by call 
rsplit
gvn
        
load of type i8* not eliminated because it is clobbered by call 
rsplit
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
        
load of type i32 not eliminated because it is clobbered by call 
formatfloat
gvn
        
load of type i8* not eliminated because it is clobbered by call 
formatfloat
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_getitem
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_getitem
1957
        assert(_PyUnicode_CheckConsistency(unicode, 1));
1958
        unicode_latin1[ch] = unicode;
1959
    }
1960
    Py_INCREF(unicode);
1961
    return unicode;
1962
}
1963
1964
static PyObject*
1965
unicode_char(Py_UCS4 ch)
1966
{
1967
    PyObject *unicode;
1968
1969
    assert(ch <= MAX_UNICODE);
1970
1971
    if (ch < 256)
1972
        return get_latin1_char(ch);
inline
               
Not inlining. Cost of inlining get_latin1_char increases the cost of inlining unicode_char in other contexts 
unicode_char
inline
               
get_latin1_char will not be inlined into unicode_char 
unicode_char
inline
               
get_latin1_char can be inlined into _PyUnicode_FromUCS2 with cost=110 (threshold=250) 
_PyUnicode_FromUCS2
inline
               
get_latin1_char inlined into _PyUnicode_FromUCS2 
_PyUnicode_FromUCS2
inline
               
get_latin1_char can be inlined into _PyUnicode_FromUCS4 with cost=110 (threshold=250) 
_PyUnicode_FromUCS4
inline
               
get_latin1_char inlined into _PyUnicode_FromUCS4 
_PyUnicode_FromUCS4
inline
               
get_latin1_char can be inlined into PyUnicode_FromOrdinal with cost=110 (threshold=250) 
PyUnicode_FromOrdinal
inline
               
get_latin1_char inlined into PyUnicode_FromOrdinal 
PyUnicode_FromOrdinal
inline
               
get_latin1_char can be inlined into unicode_getitem with cost=-14890 (threshold=250) 
unicode_getitem
inline
               
get_latin1_char inlined into unicode_getitem 
unicode_getitem
1973
1974
    unicode = PyUnicode_New(1, ch);
inline
              
PyUnicode_New too costly to inline (cost=350, threshold=250) 
unicode_char
inline
              
PyUnicode_New will not be inlined into unicode_char 
unicode_char
inline
              
PyUnicode_New too costly to inline (cost=350, threshold=250) 
_PyUnicode_FromUCS2
inline
              
PyUnicode_New will not be inlined into _PyUnicode_FromUCS2 
_PyUnicode_FromUCS2
inline
              
PyUnicode_New too costly to inline (cost=350, threshold=250) 
_PyUnicode_FromUCS4
inline
              
PyUnicode_New will not be inlined into _PyUnicode_FromUCS4 
_PyUnicode_FromUCS4
inline
              
PyUnicode_New too costly to inline (cost=350, threshold=250) 
PyUnicode_FromOrdinal
inline
              
PyUnicode_New will not be inlined into PyUnicode_FromOrdinal 
PyUnicode_FromOrdinal
inline
              
PyUnicode_New too costly to inline (cost=350, threshold=250) 
unicode_getitem
inline
              
PyUnicode_New will not be inlined into unicode_getitem 
unicode_getitem
1975
    if (unicode == NULL)
1976
        return NULL;
1977
    switch (PyUnicode_KIND(unicode)) {
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_char
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_FromUCS2
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_FromUCS4
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromOrdinal
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_getitem
1978
    case PyUnicode_1BYTE_KIND:
1979
        PyUnicode_1BYTE_DATA(unicode)[0] = (Py_UCS1)ch;
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_char
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS2
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS4
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromOrdinal
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_getitem
1980
        break;
1981
    case PyUnicode_2BYTE_KIND:
1982
        PyUnicode_2BYTE_DATA(unicode)[0] = (Py_UCS2)ch;
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_char
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS2
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS4
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromOrdinal
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_getitem
1983
        break;
1984
    default:
1985
        assert(PyUnicode_KIND(unicode) == PyUnicode_4BYTE_KIND);
1986
        PyUnicode_4BYTE_DATA(unicode)[0] = ch;
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_char
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS2
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS4
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromOrdinal
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_getitem
1987
    }
1988
    assert(_PyUnicode_CheckConsistency(unicode, 1));
1989
    return unicode;
1990
}
1991
1992
PyObject *
1993
PyUnicode_FromUnicode(const Py_UNICODE *u, Py_ssize_t size)
1994
{
1995
    PyObject *unicode;
1996
    Py_UCS4 maxchar = 0;
1997
    Py_ssize_t num_surrogates;
1998
1999
    if (u == NULL)
2000
        return (PyObject*)_PyUnicode_New(size);
inline
                          
_PyUnicode_New too costly to inline (cost=335, threshold=250) 
PyUnicode_FromUnicode
inline
                          
_PyUnicode_New will not be inlined into PyUnicode_FromUnicode 
PyUnicode_FromUnicode
inline
                          
_PyUnicode_New can be inlined into unicodeiter_reduce with cost=220 (threshold=250) 
unicodeiter_reduce
inline
                          
_PyUnicode_New inlined into unicodeiter_reduce 
unicodeiter_reduce
2001
2002
    /* If the Unicode data is known at construction time, we can apply
2003
       some optimizations which share commonly used objects. */
2004
2005
    /* Optimization for empty strings */
2006
    if (size == 0)
2007
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_FromUnicode
inline
        
PyUnicode_New will not be inlined into PyUnicode_FromUnicode 
PyUnicode_FromUnicode
gvn
        
load of type %struct._object* eliminated in favor of phi 
PyUnicode_FromUnicode
2008
2009
    /* Single character Unicode objects in the Latin-1 range are
2010
       shared when using this constructor */
2011
    if (size == 1 && (Py_UCS4)*u < 256)
2012
        return get_latin1_char((unsigned char)*u);
inline
               
get_latin1_char can be inlined into PyUnicode_FromUnicode with cost=110 (threshold=250) 
PyUnicode_FromUnicode
inline
               
get_latin1_char inlined into PyUnicode_FromUnicode 
PyUnicode_FromUnicode
2013
2014
    /* If not empty and not single character, copy the Unicode data
2015
       into the new object */
2016
    if (find_maxchar_surrogates(u, u + size,
inline
        
find_maxchar_surrogates can be inlined into PyUnicode_FromUnicode with cost=-14955 (threshold=250) 
PyUnicode_FromUnicode
inline
        
find_maxchar_surrogates inlined into PyUnicode_FromUnicode 
PyUnicode_FromUnicode
2017
                                &maxchar, &num_surrogates) == -1)
2018
        return NULL;
2019
2020
    unicode = PyUnicode_New(size - num_surrogates, maxchar);
inline
              
PyUnicode_New too costly to inline (cost=460, threshold=250) 
PyUnicode_FromUnicode
inline
              
PyUnicode_New will not be inlined into PyUnicode_FromUnicode 
PyUnicode_FromUnicode
2021
    if (!unicode)
2022
        return NULL;
2023
2024
    switch (PyUnicode_KIND(unicode)) {
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromUnicode
2025
    case PyUnicode_1BYTE_KIND:
2026
        _PyUnicode_CONVERT_BYTES(Py_UNICODE, unsigned char,
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromUnicode
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromUnicode
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromUnicode
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
PyUnicode_FromUnicode
loop-vectorize
        
loop not vectorized 
PyUnicode_FromUnicode
2027
                                u, u + size, PyUnicode_1BYTE_DATA(unicode));
2028
        break;
2029
    case PyUnicode_2BYTE_KIND:
2030
#if Py_UNICODE_SIZE == 2
2031
        memcpy(PyUnicode_2BYTE_DATA(unicode), u, size * 2);
2032
#else
2033
        _PyUnicode_CONVERT_BYTES(Py_UNICODE, Py_UCS2,
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromUnicode
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromUnicode
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
PyUnicode_FromUnicode
loop-vectorize
        
loop not vectorized 
PyUnicode_FromUnicode
2034
                                u, u + size, PyUnicode_2BYTE_DATA(unicode));
2035
#endif
2036
        break;
2037
    case PyUnicode_4BYTE_KIND:
2038
#if SIZEOF_WCHAR_T == 2
2039
        /* This is the only case which has to process surrogates, thus
2040
           a simple copy loop is not enough and we need a function. */
2041
        unicode_convert_wchar_to_ucs4(u, u + size, unicode);
2042
#else
2043
        assert(num_surrogates == 0);
2044
        memcpy(PyUnicode_4BYTE_DATA(unicode), u, size * 4);
gvn
               
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromUnicode
2045
#endif
2046
        break;
2047
    default:
2048
        assert(0 && "Impossible state");
2049
    }
2050
2051
    return unicode_result(unicode);
inline
           
unicode_result too costly to inline (cost=460, threshold=250) 
PyUnicode_FromUnicode
inline
           
unicode_result will not be inlined into PyUnicode_FromUnicode 
PyUnicode_FromUnicode
2052
}
2053
2054
PyObject *
2055
PyUnicode_FromStringAndSize(const char *u, Py_ssize_t size)
2056
{
2057
    if (size < 0) {
2058
        PyErr_SetString(PyExc_SystemError,
inline
        
PyErr_SetString will not be inlined into PyUnicode_FromStringAndSize because its definition is unavailable 
PyUnicode_FromStringAndSize
2059
                        "Negative size passed to PyUnicode_FromStringAndSize");
2060
        return NULL;
2061
    }
2062
    if (u != NULL)
2063
        return PyUnicode_DecodeUTF8Stateful(u, size, NULL, NULL);
inline
               
PyUnicode_DecodeUTF8Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_FromStringAndSize
inline
               
PyUnicode_DecodeUTF8Stateful will not be inlined into PyUnicode_FromStringAndSize 
PyUnicode_FromStringAndSize
2064
    else
2065
        return (PyObject *)_PyUnicode_New(size);
inline
                           
_PyUnicode_New too costly to inline (cost=335, threshold=250) 
PyUnicode_FromStringAndSize
inline
                           
_PyUnicode_New will not be inlined into PyUnicode_FromStringAndSize 
PyUnicode_FromStringAndSize
2066
}
2067
2068
PyObject *
2069
PyUnicode_FromString(const char *u)
2070
{
2071
    size_t size = strlen(u);
inline
                  
strlen will not be inlined into PyUnicode_FromString because its definition is unavailable 
PyUnicode_FromString
2072
    if (size > PY_SSIZE_T_MAX) {
2073
        PyErr_SetString(PyExc_OverflowError, "input too long");
inline
        
PyErr_SetString will not be inlined into PyUnicode_FromString because its definition is unavailable 
PyUnicode_FromString
2074
        return NULL;
2075
    }
2076
    return PyUnicode_DecodeUTF8Stateful(u, (Py_ssize_t)size, NULL, NULL);
inline
           
PyUnicode_DecodeUTF8Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_FromString
inline
           
PyUnicode_DecodeUTF8Stateful will not be inlined into PyUnicode_FromString 
PyUnicode_FromString
inline
           
PyUnicode_DecodeUTF8Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeLocale
inline
           
PyUnicode_DecodeUTF8Stateful will not be inlined into PyUnicode_EncodeLocale 
PyUnicode_EncodeLocale
inline
           
PyUnicode_DecodeUTF8Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeLocaleAndSize
inline
           
PyUnicode_DecodeUTF8Stateful will not be inlined into PyUnicode_DecodeLocaleAndSize 
PyUnicode_DecodeLocaleAndSize
inline
           
PyUnicode_DecodeUTF8Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_InternFromString
inline
           
PyUnicode_DecodeUTF8Stateful will not be inlined into PyUnicode_InternFromString 
PyUnicode_InternFromString
2077
}
2078
2079
PyObject *
2080
_PyUnicode_FromId(_Py_Identifier *id)
2081
{
2082
    if (!id->object) {
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIId
2083
        id->object = PyUnicode_DecodeUTF8Stateful(id->string,
inline
                     
PyUnicode_DecodeUTF8Stateful too costly to inline (cost=630, threshold=625) 
_PyUnicode_FromId
inline
                     
PyUnicode_DecodeUTF8Stateful will not be inlined into _PyUnicode_FromId 
_PyUnicode_FromId
inline
                     
PyUnicode_DecodeUTF8Stateful too costly to inline (cost=630, threshold=625) 
_PyUnicode_EqualToASCIIId
inline
                     
PyUnicode_DecodeUTF8Stateful will not be inlined into _PyUnicode_EqualToASCIIId 
_PyUnicode_EqualToASCIIId
gvn
                                                      
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIId
2084
                                                  strlen(id->string),
inline
                                                  
strlen will not be inlined into _PyUnicode_FromId because its definition is unavailable 
_PyUnicode_FromId
2085
                                                  NULL, NULL);
2086
        if (!id->object)
2087
            return NULL;
2088
        PyUnicode_InternInPlace(&id->object);
inline
        
PyUnicode_InternInPlace too costly to inline (cost=355, threshold=250) 
_PyUnicode_FromId
inline
        
PyUnicode_InternInPlace will not be inlined into _PyUnicode_FromId 
_PyUnicode_FromId
inline
        
PyUnicode_InternInPlace too costly to inline (cost=355, threshold=250) 
_PyUnicode_EqualToASCIIId
inline
        
PyUnicode_InternInPlace will not be inlined into _PyUnicode_EqualToASCIIId 
_PyUnicode_EqualToASCIIId
2089
        assert(!id->next);
2090
        id->next = static_strings;
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_FromId
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIId
2091
        static_strings = id;
2092
    }
2093
    return id->object;
gvn
               
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_FromId
gvn
               
load eliminated by PRE 
_PyUnicode_FromId
2094
}
2095
2096
void
2097
_PyUnicode_ClearStaticStrings()
2098
{
2099
    _Py_Identifier *tmp, *s = static_strings;
gvn
                              
load of type %struct._Py_Identifier* not eliminated because it is clobbered by call 
_PyUnicode_Fini
gvn
                              
load of type %struct._Py_Identifier* not eliminated because it is clobbered by call 
_PyUnicode_Fini
2100
    while (s) {
loop-vectorize
    
loop not vectorized 
_PyUnicode_ClearStaticStrings
loop-vectorize
    
loop not vectorized 
_PyUnicode_Fini
2101
        Py_CLEAR(s->object);
loop-vectorize
        
loop not vectorized: control flow cannot be substituted for a select 
_PyUnicode_ClearStaticStrings
loop-vectorize
        
loop not vectorized: control flow cannot be substituted for a select 
_PyUnicode_Fini
2102
        tmp = s->next;
gvn
                 
load of type %struct._Py_Identifier* not eliminated because it is clobbered by call 
_PyUnicode_ClearStaticStrings
gvn
                 
load of type %struct._Py_Identifier* not eliminated because it is clobbered by call 
_PyUnicode_Fini
2103
        s->next = NULL;
2104
        s = tmp;
2105
    }
2106
    static_strings = NULL;
2107
}
2108
2109
/* Internal function, doesn't check maximum character */
2110
2111
PyObject*
2112
_PyUnicode_FromASCII(const char *buffer, Py_ssize_t size)
2113
{
2114
    const unsigned char *s = (const unsigned char *)buffer;
2115
    PyObject *unicode;
2116
    if (size == 1) {
2117
#ifdef Py_DEBUG
2118
        assert((unsigned char)s[0] < 128);
2119
#endif
2120
        return get_latin1_char(s[0]);
inline
               
get_latin1_char can be inlined into _PyUnicode_FromASCII with cost=110 (threshold=250) 
_PyUnicode_FromASCII
inline
               
get_latin1_char inlined into _PyUnicode_FromASCII 
_PyUnicode_FromASCII
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_splitlines
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_splitlines
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_Splitlines
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_Splitlines
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_split_whitespace
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_split_whitespace
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_split_char
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_split
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_split
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
split
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
split
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
split
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
split
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_partition
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
asciilib_partition
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_Partition
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_Partition
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_rpartition
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
asciilib_rpartition
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_RPartition
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_RPartition
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_rsplit_whitespace
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_rsplit_whitespace
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
asciilib_rsplit_whitespace
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_rsplit_whitespace
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_rsplit_whitespace
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_rsplit_char
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
asciilib_rsplit_char
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_rsplit_char
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
asciilib_rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
asciilib_rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
asciilib_rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
rsplit
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_FormatLong
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_FormatLong
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
formatfloat
2121
    }
2122
    unicode = PyUnicode_New(size, 127);
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
_PyUnicode_FromASCII
inline
              
PyUnicode_New will not be inlined into _PyUnicode_FromASCII 
_PyUnicode_FromASCII
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
_PyUnicodeWriter_WriteASCIIString
inline
              
PyUnicode_New will not be inlined into _PyUnicodeWriter_WriteASCIIString 
_PyUnicodeWriter_WriteASCIIString
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
asciilib_splitlines
inline
              
PyUnicode_New will not be inlined into asciilib_splitlines 
asciilib_splitlines
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
PyUnicode_Splitlines
inline
              
PyUnicode_New will not be inlined into PyUnicode_Splitlines 
PyUnicode_Splitlines
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
PyUnicode_Substring
inline
              
PyUnicode_New will not be inlined into PyUnicode_Substring 
PyUnicode_Substring
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
asciilib_split_whitespace
inline
              
PyUnicode_New will not be inlined into asciilib_split_whitespace 
asciilib_split_whitespace
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
asciilib_split_char
inline
              
PyUnicode_New will not be inlined into asciilib_split_char 
asciilib_split_char
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
asciilib_split
inline
              
PyUnicode_New will not be inlined into asciilib_split 
asciilib_split
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
split
inline
              
PyUnicode_New will not be inlined into split 
split
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
asciilib_partition
inline
              
PyUnicode_New will not be inlined into asciilib_partition 
asciilib_partition
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
PyUnicode_Partition
inline
              
PyUnicode_New will not be inlined into PyUnicode_Partition 
PyUnicode_Partition
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
asciilib_rpartition
inline
              
PyUnicode_New will not be inlined into asciilib_rpartition 
asciilib_rpartition
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
PyUnicode_RPartition
inline
              
PyUnicode_New will not be inlined into PyUnicode_RPartition 
PyUnicode_RPartition
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
asciilib_rsplit_whitespace
inline
              
PyUnicode_New will not be inlined into asciilib_rsplit_whitespace 
asciilib_rsplit_whitespace
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
asciilib_rsplit_char
inline
              
PyUnicode_New will not be inlined into asciilib_rsplit_char 
asciilib_rsplit_char
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
asciilib_rsplit
inline
              
PyUnicode_New will not be inlined into asciilib_rsplit 
asciilib_rsplit
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
rsplit
inline
              
PyUnicode_New will not be inlined into rsplit 
rsplit
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
_PyUnicode_FormatLong
inline
              
PyUnicode_New will not be inlined into _PyUnicode_FormatLong 
_PyUnicode_FormatLong
inline
              
PyUnicode_New too costly to inline (cost=375, threshold=250) 
formatfloat
inline
              
PyUnicode_New will not be inlined into formatfloat 
formatfloat
2123
    if (!unicode)
2124
        return NULL;
2125
    memcpy(PyUnicode_1BYTE_DATA(unicode), s, size);
gvn
           
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_FromASCII
gvn
           
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromASCII
gvn
           
load of type i32 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
gvn
           
load of type i8* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
gvn
           
load of type i32 not eliminated because it is clobbered by call 
asciilib_splitlines
gvn
           
load of type i8* not eliminated because it is clobbered by call 
asciilib_splitlines
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Splitlines
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Splitlines
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Substring
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Substring
gvn
           
load of type i32 not eliminated because it is clobbered by call 
asciilib_split_whitespace
gvn
           
load of type i8* not eliminated because it is clobbered by call 
asciilib_split_whitespace
gvn
           
load of type i32 not eliminated because it is clobbered by call 
asciilib_split_char
gvn
           
load of type i8* not eliminated because it is clobbered by call 
asciilib_split_char
gvn
           
load of type i32 not eliminated because it is clobbered by call 
asciilib_split
gvn
           
load of type i8* not eliminated because it is clobbered by call 
asciilib_split
gvn
           
load of type i32 not eliminated because it is clobbered by call 
split
gvn
           
load of type i8* not eliminated because it is clobbered by call 
split
gvn
           
load of type i32 not eliminated because it is clobbered by call 
asciilib_partition
gvn
           
load of type i8* not eliminated because it is clobbered by call 
asciilib_partition
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Partition
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Partition
gvn
           
load of type i32 not eliminated because it is clobbered by call 
asciilib_rpartition
gvn
           
load of type i8* not eliminated because it is clobbered by call 
asciilib_rpartition
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_RPartition
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_RPartition
gvn
           
load of type i32 not eliminated because it is clobbered by call 
asciilib_rsplit_whitespace
gvn
           
load of type i8* not eliminated because it is clobbered by call 
asciilib_rsplit_whitespace
gvn
           
load of type i32 not eliminated because it is clobbered by call 
asciilib_rsplit_char
gvn
           
load of type i8* not eliminated because it is clobbered by call 
asciilib_rsplit_char
gvn
           
load of type i32 not eliminated because it is clobbered by call 
asciilib_rsplit
gvn
           
load of type i8* not eliminated because it is clobbered by call 
asciilib_rsplit
gvn
           
load of type i32 not eliminated because it is clobbered by call 
rsplit
gvn
           
load of type i8* not eliminated because it is clobbered by call 
rsplit
gvn
           
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
           
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
           
load of type i32 not eliminated because it is clobbered by call 
formatfloat
gvn
           
load of type i8* not eliminated because it is clobbered by call 
formatfloat
2126
    assert(_PyUnicode_CheckConsistency(unicode, 1));
2127
    return unicode;
2128
}
2129
2130
static Py_UCS4
2131
kind_maxchar_limit(unsigned int kind)
2132
{
2133
    switch (kind) {
2134
    case PyUnicode_1BYTE_KIND:
2135
        return 0x80;
2136
    case PyUnicode_2BYTE_KIND:
2137
        return 0x100;
2138
    case PyUnicode_4BYTE_KIND:
2139
        return 0x10000;
2140
    default:
2141
        assert(0 && "invalid kind");
2142
        return MAX_UNICODE;
2143
    }
2144
}
2145
2146
static inline Py_UCS4
2147
align_maxchar(Py_UCS4 maxchar)
2148
{
2149
    if (maxchar <= 127)
2150
        return 127;
2151
    else if (maxchar <= 255)
2152
        return 255;
2153
    else if (maxchar <= 65535)
2154
        return 65535;
2155
    else
2156
        return MAX_UNICODE;
2157
}
2158
2159
static PyObject*
2160
_PyUnicode_FromUCS1(const Py_UCS1* u, Py_ssize_t size)
2161
{
2162
    PyObject *res;
2163
    unsigned char max_char;
2164
2165
    if (size == 0)
2166
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
_PyUnicode_FromUCS1
inline
        
PyUnicode_New will not be inlined into _PyUnicode_FromUCS1 
_PyUnicode_FromUCS1
gvn
        
load of type %struct._object* eliminated in favor of phi 
_PyUnicode_FromUCS1
2167
    assert(size > 0);
2168
    if (size == 1)
2169
        return get_latin1_char(u[0]);
inline
               
get_latin1_char can be inlined into _PyUnicode_FromUCS1 with cost=110 (threshold=250) 
_PyUnicode_FromUCS1
inline
               
get_latin1_char inlined into _PyUnicode_FromUCS1 
_PyUnicode_FromUCS1
2170
2171
    max_char = ucs1lib_find_max_char(u, u + size);
inline
               
ucs1lib_find_max_char can be inlined into _PyUnicode_FromUCS1 with cost=60 (threshold=325) 
_PyUnicode_FromUCS1
inline
               
ucs1lib_find_max_char inlined into _PyUnicode_FromUCS1 
_PyUnicode_FromUCS1
2172
    res = PyUnicode_New(size, max_char);
inline
          
PyUnicode_New too costly to inline (cost=460, threshold=250) 
_PyUnicode_FromUCS1
inline
          
PyUnicode_New will not be inlined into _PyUnicode_FromUCS1 
_PyUnicode_FromUCS1
2173
    if (!res)
2174
        return NULL;
2175
    memcpy(PyUnicode_1BYTE_DATA(res), u, size);
gvn
           
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_FromUCS1
gvn
           
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS1
2176
    assert(_PyUnicode_CheckConsistency(res, 1));
2177
    return res;
2178
}
2179
2180
static PyObject*
2181
_PyUnicode_FromUCS2(const Py_UCS2 *u, Py_ssize_t size)
2182
{
2183
    PyObject *res;
2184
    Py_UCS2 max_char;
2185
2186
    if (size == 0)
2187
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
_PyUnicode_FromUCS2
inline
        
PyUnicode_New will not be inlined into _PyUnicode_FromUCS2 
_PyUnicode_FromUCS2
gvn
        
load of type %struct._object* eliminated in favor of phi 
_PyUnicode_FromUCS2
2188
    assert(size > 0);
2189
    if (size == 1)
2190
        return unicode_char(u[0]);
inline
               
unicode_char can be inlined into _PyUnicode_FromUCS2 with cost=205 (threshold=250) 
_PyUnicode_FromUCS2
inline
               
unicode_char inlined into _PyUnicode_FromUCS2 
_PyUnicode_FromUCS2
2191
2192
    max_char = ucs2lib_find_max_char(u, u + size);
inline
               
ucs2lib_find_max_char can be inlined into _PyUnicode_FromUCS2 with cost=130 (threshold=325) 
_PyUnicode_FromUCS2
inline
               
ucs2lib_find_max_char inlined into _PyUnicode_FromUCS2 
_PyUnicode_FromUCS2
2193
    res = PyUnicode_New(size, max_char);
inline
          
PyUnicode_New too costly to inline (cost=460, threshold=250) 
_PyUnicode_FromUCS2
inline
          
PyUnicode_New will not be inlined into _PyUnicode_FromUCS2 
_PyUnicode_FromUCS2
2194
    if (!res)
2195
        return NULL;
2196
    if (max_char >= 256)
2197
        memcpy(PyUnicode_2BYTE_DATA(res), u, sizeof(Py_UCS2)*size);
gvn
               
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS2
2198
    else {
2199
        _PyUnicode_CONVERT_BYTES(
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS2
gvn
        
load of type i16 not eliminated because it is clobbered by call 
_PyUnicode_FromUCS2
gvn
        
load of type i16 not eliminated because it is clobbered by store 
_PyUnicode_FromUCS2
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
_PyUnicode_FromUCS2
loop-vectorize
        
loop not vectorized 
_PyUnicode_FromUCS2
2200
            Py_UCS2, Py_UCS1, u, u + size, PyUnicode_1BYTE_DATA(res));
2201
    }
2202
    assert(_PyUnicode_CheckConsistency(res, 1));
2203
    return res;
2204
}
2205
2206
static PyObject*
2207
_PyUnicode_FromUCS4(const Py_UCS4 *u, Py_ssize_t size)
2208
{
2209
    PyObject *res;
2210
    Py_UCS4 max_char;
2211
2212
    if (size == 0)
2213
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
_PyUnicode_FromUCS4
inline
        
PyUnicode_New will not be inlined into _PyUnicode_FromUCS4 
_PyUnicode_FromUCS4
gvn
        
load of type %struct._object* eliminated in favor of phi 
_PyUnicode_FromUCS4
2214
    assert(size > 0);
2215
    if (size == 1)
2216
        return unicode_char(u[0]);
inline
               
unicode_char can be inlined into _PyUnicode_FromUCS4 with cost=205 (threshold=250) 
_PyUnicode_FromUCS4
inline
               
unicode_char inlined into _PyUnicode_FromUCS4 
_PyUnicode_FromUCS4
2217
2218
    max_char = ucs4lib_find_max_char(u, u + size);
inline
               
ucs4lib_find_max_char can be inlined into _PyUnicode_FromUCS4 with cost=120 (threshold=325) 
_PyUnicode_FromUCS4
inline
               
ucs4lib_find_max_char inlined into _PyUnicode_FromUCS4 
_PyUnicode_FromUCS4
2219
    res = PyUnicode_New(size, max_char);
inline
          
PyUnicode_New too costly to inline (cost=460, threshold=250) 
_PyUnicode_FromUCS4
inline
          
PyUnicode_New will not be inlined into _PyUnicode_FromUCS4 
_PyUnicode_FromUCS4
2220
    if (!res)
2221
        return NULL;
2222
    if (max_char < 256)
2223
        _PyUnicode_CONVERT_BYTES(Py_UCS4, Py_UCS1, u, u + size,
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_FromUCS4
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS4
gvn
        
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_FromUCS4
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
_PyUnicode_FromUCS4
loop-vectorize
        
loop not vectorized 
_PyUnicode_FromUCS4
2224
                                 PyUnicode_1BYTE_DATA(res));
2225
    else if (max_char < 0x10000)
2226
        _PyUnicode_CONVERT_BYTES(Py_UCS4, Py_UCS2, u, u + size,
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS4
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_FromUCS4
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
_PyUnicode_FromUCS4
loop-vectorize
        
loop not vectorized 
_PyUnicode_FromUCS4
2227
                                 PyUnicode_2BYTE_DATA(res));
2228
    else
2229
        memcpy(PyUnicode_4BYTE_DATA(res), u, sizeof(Py_UCS4)*size);
gvn
               
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_FromUCS4
2230
    assert(_PyUnicode_CheckConsistency(res, 1));
2231
    return res;
2232
}
2233
2234
PyObject*
2235
PyUnicode_FromKindAndData(int kind, const void *buffer, Py_ssize_t size)
2236
{
2237
    if (size < 0) {
2238
        PyErr_SetString(PyExc_ValueError, "size must be positive");
inline
        
PyErr_SetString will not be inlined into PyUnicode_FromKindAndData because its definition is unavailable 
PyUnicode_FromKindAndData
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Substring
2239
        return NULL;
2240
    }
2241
    switch (kind) {
2242
    case PyUnicode_1BYTE_KIND:
2243
        return _PyUnicode_FromUCS1(buffer, size);
inline
               
_PyUnicode_FromUCS1 too costly to inline (cost=410, threshold=250) 
PyUnicode_FromKindAndData
inline
               
_PyUnicode_FromUCS1 will not be inlined into PyUnicode_FromKindAndData 
PyUnicode_FromKindAndData
inline
               
_PyUnicode_FromUCS1 too costly to inline (cost=410, threshold=250) 
PyUnicode_DecodeUTF7Stateful
inline
               
_PyUnicode_FromUCS1 will not be inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
inline
               
_PyUnicode_FromUCS1 too costly to inline (cost=410, threshold=250) 
PyUnicode_Substring
inline
               
_PyUnicode_FromUCS1 will not be inlined into PyUnicode_Substring 
PyUnicode_Substring
2244
    case PyUnicode_2BYTE_KIND:
2245
        return _PyUnicode_FromUCS2(buffer, size);
inline
               
_PyUnicode_FromUCS2 too costly to inline (cost=630, threshold=625) 
PyUnicode_FromKindAndData
inline
               
_PyUnicode_FromUCS2 will not be inlined into PyUnicode_FromKindAndData 
PyUnicode_FromKindAndData
inline
               
_PyUnicode_FromUCS2 too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF7Stateful
inline
               
_PyUnicode_FromUCS2 will not be inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
inline
               
_PyUnicode_FromUCS2 too costly to inline (cost=630, threshold=625) 
PyUnicode_Substring
inline
               
_PyUnicode_FromUCS2 will not be inlined into PyUnicode_Substring 
PyUnicode_Substring
2246
    case PyUnicode_4BYTE_KIND:
2247
        return _PyUnicode_FromUCS4(buffer, size);
inline
               
_PyUnicode_FromUCS4 too costly to inline (cost=630, threshold=625) 
PyUnicode_FromKindAndData
inline
               
_PyUnicode_FromUCS4 will not be inlined into PyUnicode_FromKindAndData 
PyUnicode_FromKindAndData
inline
               
_PyUnicode_FromUCS4 too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF7Stateful
inline
               
_PyUnicode_FromUCS4 will not be inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
inline
               
_PyUnicode_FromUCS4 too costly to inline (cost=630, threshold=625) 
PyUnicode_Substring
inline
               
_PyUnicode_FromUCS4 will not be inlined into PyUnicode_Substring 
PyUnicode_Substring
inline
               
_PyUnicode_FromUCS4 too costly to inline (cost=305, threshold=250) 
formatteriter_next
inline
               
_PyUnicode_FromUCS4 will not be inlined into formatteriter_next 
formatteriter_next
2248
    default:
2249
        PyErr_SetString(PyExc_SystemError, "invalid kind");
inline
        
PyErr_SetString will not be inlined into PyUnicode_FromKindAndData because its definition is unavailable 
PyUnicode_FromKindAndData
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Substring
2250
        return NULL;
2251
    }
2252
}
2253
2254
Py_UCS4
2255
_PyUnicode_FindMaxChar(PyObject *unicode, Py_ssize_t start, Py_ssize_t end)
2256
{
2257
    enum PyUnicode_Kind kind;
2258
    void *startptr, *endptr;
2259
2260
    assert(PyUnicode_IS_READY(unicode));
2261
    assert(0 <= start);
2262
    assert(end <= PyUnicode_GET_LENGTH(unicode));
2263
    assert(start <= end);
2264
2265
    if (start == 0 && end == PyUnicode_GET_LENGTH(unicode))
2266
        return PyUnicode_MAX_CHAR_VALUE(unicode);
2267
2268
    if (start == end)
2269
        return 127;
2270
2271
    if (PyUnicode_IS_ASCII(unicode))
2272
        return 127;
2273
2274
    kind = PyUnicode_KIND(unicode);
2275
    startptr = PyUnicode_DATA(unicode);
2276
    endptr = (char *)startptr + end * kind;
2277
    startptr = (char *)startptr + start * kind;
2278
    switch(kind) {
2279
    case PyUnicode_1BYTE_KIND:
2280
        return ucs1lib_find_max_char(startptr, endptr);
inline
               
ucs1lib_find_max_char can be inlined into _PyUnicode_FindMaxChar with cost=60 (threshold=325) 
_PyUnicode_FindMaxChar
inline
               
ucs1lib_find_max_char inlined into _PyUnicode_FindMaxChar 
_PyUnicode_FindMaxChar
2281
    case PyUnicode_2BYTE_KIND:
2282
        return ucs2lib_find_max_char(startptr, endptr);
inline
               
ucs2lib_find_max_char can be inlined into _PyUnicode_FindMaxChar with cost=130 (threshold=325) 
_PyUnicode_FindMaxChar
inline
               
ucs2lib_find_max_char inlined into _PyUnicode_FindMaxChar 
_PyUnicode_FindMaxChar
2283
    case PyUnicode_4BYTE_KIND:
2284
        return ucs4lib_find_max_char(startptr, endptr);
inline
               
ucs4lib_find_max_char can be inlined into _PyUnicode_FindMaxChar with cost=120 (threshold=325) 
_PyUnicode_FindMaxChar
inline
               
ucs4lib_find_max_char inlined into _PyUnicode_FindMaxChar 
_PyUnicode_FindMaxChar
2285
    default:
2286
        assert(0);
2287
        return 0;
2288
    }
2289
}
2290
2291
/* Ensure that a string uses the most efficient storage, if it is not the
2292
   case: create a new string with of the right kind. Write NULL into *p_unicode
2293
   on error. */
2294
static void
2295
unicode_adjust_maxchar(PyObject **p_unicode)
2296
{
2297
    PyObject *unicode, *copy;
2298
    Py_UCS4 max_char;
2299
    Py_ssize_t len;
2300
    unsigned int kind;
2301
2302
    assert(p_unicode != NULL);
2303
    unicode = *p_unicode;
2304
    assert(PyUnicode_IS_READY(unicode));
2305
    if (PyUnicode_IS_ASCII(unicode))
gvn
        
load of type i32 not eliminated because it is clobbered by store 
replace
gvn
        
load of type i32 not eliminated because it is clobbered by call 
replace
gvn
        
load of type i32 not eliminated because it is clobbered by call 
replace
gvn
        
load of type i32 not eliminated because it is clobbered by call 
replace
gvn
        
load of type i32 not eliminated because it is clobbered by call 
replace
gvn
        
load of type i32 not eliminated because it is clobbered by call 
replace
gvn
        
load of type i32 not eliminated because it is clobbered by call 
replace
2306
        return;
2307
2308
    len = PyUnicode_GET_LENGTH(unicode);
gvn
          
load of type i64 not eliminated because it is clobbered by store 
replace
2309
    kind = PyUnicode_KIND(unicode);
2310
    if (kind == PyUnicode_1BYTE_KIND) {
2311
        const Py_UCS1 *u = PyUnicode_1BYTE_DATA(unicode);
gvn
                           
load of type i8* not eliminated because it is clobbered by store 
replace
gvn
                           
load of type i8* not eliminated because it is clobbered by call 
replace
2312
        max_char = ucs1lib_find_max_char(u, u + len);
inline
                   
ucs1lib_find_max_char can be inlined into unicode_adjust_maxchar with cost=-14940 (threshold=325) 
unicode_adjust_maxchar
inline
                   
ucs1lib_find_max_char inlined into unicode_adjust_maxchar 
unicode_adjust_maxchar
2313
        if (max_char >= 128)
2314
            return;
2315
    }
2316
    else if (kind == PyUnicode_2BYTE_KIND) {
2317
        const Py_UCS2 *u = PyUnicode_2BYTE_DATA(unicode);
gvn
                           
load of type i8* not eliminated because it is clobbered by store 
replace
gvn
                           
load of type i8* not eliminated because it is clobbered by call 
replace
2318
        max_char = ucs2lib_find_max_char(u, u + len);
inline
                   
ucs2lib_find_max_char can be inlined into unicode_adjust_maxchar with cost=-14870 (threshold=325) 
unicode_adjust_maxchar
inline
                   
ucs2lib_find_max_char inlined into unicode_adjust_maxchar 
unicode_adjust_maxchar
2319
        if (max_char >= 256)
2320
            return;
2321
    }
2322
    else {
2323
        const Py_UCS4 *u = PyUnicode_4BYTE_DATA(unicode);
gvn
                           
load of type i8* not eliminated because it is clobbered by store 
replace
gvn
                           
load of type i8* not eliminated because it is clobbered by call 
replace
2324
        assert(kind == PyUnicode_4BYTE_KIND);
2325
        max_char = ucs4lib_find_max_char(u, u + len);
inline
                   
ucs4lib_find_max_char can be inlined into unicode_adjust_maxchar with cost=-14880 (threshold=325) 
unicode_adjust_maxchar
inline
                   
ucs4lib_find_max_char inlined into unicode_adjust_maxchar 
unicode_adjust_maxchar
2326
        if (max_char >= 0x10000)
2327
            return;
2328
    }
2329
    copy = PyUnicode_New(len, max_char);
inline
           
PyUnicode_New too costly to inline (cost=460, threshold=250) 
unicode_adjust_maxchar
inline
           
PyUnicode_New will not be inlined into unicode_adjust_maxchar 
unicode_adjust_maxchar
inline
           
PyUnicode_New too costly to inline (cost=460, threshold=250) 
replace
inline
           
PyUnicode_New will not be inlined into replace 
replace
2330
    if (copy != NULL)
2331
        _PyUnicode_FastCopyCharacters(copy, 0, unicode, 0, len);
inline
        
_PyUnicode_FastCopyCharacters can be inlined into unicode_adjust_maxchar with cost=5 (threshold=375) 
unicode_adjust_maxchar
inline
        
_PyUnicode_FastCopyCharacters inlined into unicode_adjust_maxchar 
unicode_adjust_maxchar
2332
    Py_DECREF(unicode);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_adjust_maxchar
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_adjust_maxchar
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_adjust_maxchar
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_adjust_maxchar
gvn
    
load of type i64 not eliminated because it is clobbered by call 
replace
gvn
    
load of type i64 not eliminated because it is clobbered by call 
replace
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
replace
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
replace
2333
    *p_unicode = copy;
2334
}
2335
2336
PyObject*
2337
_PyUnicode_Copy(PyObject *unicode)
2338
{
2339
    Py_ssize_t length;
2340
    PyObject *copy;
2341
2342
    if (!PyUnicode_Check(unicode)) {
2343
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into _PyUnicode_Copy because its definition is unavailable 
_PyUnicode_Copy
2344
        return NULL;
2345
    }
2346
    if (PyUnicode_READY(unicode) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_Copy
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_Copy 
_PyUnicode_Copy
2347
        return NULL;
2348
2349
    length = PyUnicode_GET_LENGTH(unicode);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_Copy
2350
    copy = PyUnicode_New(length, PyUnicode_MAX_CHAR_VALUE(unicode));
inline
           
PyUnicode_New too costly to inline (cost=460, threshold=250) 
_PyUnicode_Copy
inline
           
PyUnicode_New will not be inlined into _PyUnicode_Copy 
_PyUnicode_Copy
gvn
                                 
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_Copy
gvn
                                 
load eliminated by PRE 
_PyUnicode_Copy
2351
    if (!copy)
2352
        return NULL;
2353
    assert(PyUnicode_KIND(copy) == PyUnicode_KIND(unicode));
2354
2355
    memcpy(PyUnicode_DATA(copy), PyUnicode_DATA(unicode),
gvn
           
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_Copy
gvn
           
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_Copy
gvn
                                 
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_Copy
gvn
                                 
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_Copy
2356
              length * PyUnicode_KIND(unicode));
2357
    assert(_PyUnicode_CheckConsistency(copy, 1));
2358
    return copy;
2359
}
2360
2361
2362
/* Widen Unicode objects to larger buffers. Don't write terminating null
2363
   character. Return NULL on error. */
2364
2365
void*
2366
_PyUnicode_AsKind(PyObject *s, unsigned int kind)
2367
{
2368
    Py_ssize_t len;
2369
    void *result;
2370
    unsigned int skind;
2371
2372
    if (PyUnicode_READY(s) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_AsKind
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_AsKind 
_PyUnicode_AsKind
2373
        return NULL;
2374
2375
    len = PyUnicode_GET_LENGTH(s);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_AsKind
2376
    skind = PyUnicode_KIND(s);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_AsKind
gvn
            
load eliminated by PRE 
_PyUnicode_AsKind
2377
    if (skind >= kind) {
2378
        PyErr_SetString(PyExc_SystemError, "invalid widening attempt");
inline
        
PyErr_SetString will not be inlined into _PyUnicode_AsKind because its definition is unavailable 
_PyUnicode_AsKind
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_AsKind
2379
        return NULL;
2380
    }
2381
    switch (kind) {
2382
    case PyUnicode_2BYTE_KIND:
2383
        result = PyMem_New(Py_UCS2, len);
inline
                 
PyMem_Malloc will not be inlined into _PyUnicode_AsKind because its definition is unavailable 
_PyUnicode_AsKind
2384
        if (!result)
2385
            return PyErr_NoMemory();
inline
                   
PyErr_NoMemory will not be inlined into _PyUnicode_AsKind because its definition is unavailable 
_PyUnicode_AsKind
2386
        assert(skind == PyUnicode_1BYTE_KIND);
2387
        _PyUnicode_CONVERT_BYTES(
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_AsKind
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_AsKind
gvn
        
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_AsKind
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
_PyUnicode_AsKind
loop-vectorize
        
loop not vectorized 
_PyUnicode_AsKind
loop-vectorize
        
vectorized loop (vectorization width: 8, interleaved count: 2) 
_PyUnicode_AsKind
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
_PyUnicode_AsKind
2388
            Py_UCS1, Py_UCS2,
2389
            PyUnicode_1BYTE_DATA(s),
2390
            PyUnicode_1BYTE_DATA(s) + len,
2391
            result);
2392
        return result;
2393
    case PyUnicode_4BYTE_KIND:
2394
        result = PyMem_New(Py_UCS4, len);
inline
                 
PyMem_Malloc will not be inlined into _PyUnicode_AsKind because its definition is unavailable 
_PyUnicode_AsKind
2395
        if (!result)
2396
            return PyErr_NoMemory();
inline
                   
PyErr_NoMemory will not be inlined into _PyUnicode_AsKind because its definition is unavailable 
_PyUnicode_AsKind
2397
        if (skind == PyUnicode_2BYTE_KIND) {
2398
            _PyUnicode_CONVERT_BYTES(
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_AsKind
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_AsKind
loop-vectorize
            
loop not vectorized: could not determine number of loop iterations 
_PyUnicode_AsKind
loop-vectorize
            
loop not vectorized 
_PyUnicode_AsKind
2399
                Py_UCS2, Py_UCS4,
2400
                PyUnicode_2BYTE_DATA(s),
2401
                PyUnicode_2BYTE_DATA(s) + len,
2402
                result);
2403
        }
2404
        else {
2405
            assert(skind == PyUnicode_1BYTE_KIND);
2406
            _PyUnicode_CONVERT_BYTES(
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_AsKind
gvn
            
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_AsKind
loop-vectorize
            
loop not vectorized: could not determine number of loop iterations 
_PyUnicode_AsKind
loop-vectorize
            
loop not vectorized 
_PyUnicode_AsKind
loop-vectorize
            
vectorized loop (vectorization width: 4, interleaved count: 2) 
_PyUnicode_AsKind
loop-unroll
            
unrolled loop by a factor of 2 with run-time trip count 
_PyUnicode_AsKind
2407
                Py_UCS1, Py_UCS4,
2408
                PyUnicode_1BYTE_DATA(s),
2409
                PyUnicode_1BYTE_DATA(s) + len,
2410
                result);
2411
        }
2412
        return result;
2413
    default:
2414
        break;
2415
    }
2416
    PyErr_SetString(PyExc_SystemError, "invalid kind");
inline
    
PyErr_SetString will not be inlined into _PyUnicode_AsKind because its definition is unavailable 
_PyUnicode_AsKind
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_AsKind
2417
    return NULL;
2418
}
2419
2420
static Py_UCS4*
2421
as_ucs4(PyObject *string, Py_UCS4 *target, Py_ssize_t targetsize,
2422
        int copy_null)
2423
{
2424
    int kind;
2425
    void *data;
2426
    Py_ssize_t len, targetlen;
2427
    if (PyUnicode_READY(string) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
as_ucs4
inline
        
_PyUnicode_Ready will not be inlined into as_ucs4 
as_ucs4
2428
        return NULL;
2429
    kind = PyUnicode_KIND(string);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
as_ucs4
gvn
           
load eliminated by PRE 
as_ucs4
2430
    data = PyUnicode_DATA(string);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
as_ucs4
2431
    len = PyUnicode_GET_LENGTH(string);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
as_ucs4
2432
    targetlen = len;
2433
    if (copy_null)
2434
        targetlen++;
2435
    if (!target) {
2436
        target = PyMem_New(Py_UCS4, targetlen);
inline
                 
PyMem_Malloc will not be inlined into as_ucs4 because its definition is unavailable 
as_ucs4
2437
        if (!target) {
2438
            PyErr_NoMemory();
inline
            
PyErr_NoMemory will not be inlined into as_ucs4 because its definition is unavailable 
as_ucs4
2439
            return NULL;
2440
        }
2441
    }
2442
    else {
2443
        if (targetsize < targetlen) {
2444
            PyErr_Format(PyExc_SystemError,
inline
            
PyErr_Format will not be inlined into as_ucs4 because its definition is unavailable 
as_ucs4
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
as_ucs4
2445
                         "string is longer than the buffer");
2446
            if (copy_null && 0 < targetsize)
2447
                target[0] = 0;
2448
            return NULL;
2449
        }
2450
    }
2451
    if (kind == PyUnicode_1BYTE_KIND) {
2452
        Py_UCS1 *start = (Py_UCS1 *) data;
2453
        _PyUnicode_CONVERT_BYTES(Py_UCS1, Py_UCS4, start, start + len, target);
gvn
        
load of type i8 not eliminated because it is clobbered by call 
as_ucs4
gvn
        
load of type i8 not eliminated because it is clobbered by store 
as_ucs4
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
as_ucs4
loop-vectorize
        
loop not vectorized 
as_ucs4
loop-vectorize
        
vectorized loop (vectorization width: 4, interleaved count: 2) 
as_ucs4
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
as_ucs4
2454
    }
2455
    else if (kind == PyUnicode_2BYTE_KIND) {
2456
        Py_UCS2 *start = (Py_UCS2 *) data;
2457
        _PyUnicode_CONVERT_BYTES(Py_UCS2, Py_UCS4, start, start + len, target);
gvn
        
load of type i16 not eliminated because it is clobbered by call 
as_ucs4
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
as_ucs4
loop-vectorize
        
loop not vectorized 
as_ucs4
2458
    }
2459
    else {
2460
        assert(kind == PyUnicode_4BYTE_KIND);
2461
        memcpy(target, data, len * sizeof(Py_UCS4));
2462
    }
2463
    if (copy_null)
2464
        target[len] = 0;
2465
    return target;
2466
}
2467
2468
Py_UCS4*
2469
PyUnicode_AsUCS4(PyObject *string, Py_UCS4 *target, Py_ssize_t targetsize,
2470
                 int copy_null)
2471
{
2472
    if (target == NULL || targetsize < 0) {
2473
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into PyUnicode_AsUCS4 because its definition is unavailable 
PyUnicode_AsUCS4
2474
        return NULL;
2475
    }
2476
    return as_ucs4(string, target, targetsize, copy_null);
inline
           
as_ucs4 too costly to inline (cost=555, threshold=250) 
PyUnicode_AsUCS4
inline
           
as_ucs4 will not be inlined into PyUnicode_AsUCS4 
PyUnicode_AsUCS4
2477
}
2478
2479
Py_UCS4*
2480
PyUnicode_AsUCS4Copy(PyObject *string)
2481
{
2482
    return as_ucs4(string, NULL, 0, 1);
inline
           
as_ucs4 too costly to inline (cost=460, threshold=250) 
PyUnicode_AsUCS4Copy
inline
           
as_ucs4 will not be inlined into PyUnicode_AsUCS4Copy 
PyUnicode_AsUCS4Copy
2483
}
2484
2485
#ifdef HAVE_WCHAR_H
2486
2487
PyObject *
2488
PyUnicode_FromWideChar(const wchar_t *w, Py_ssize_t size)
2489
{
2490
    if (w == NULL) {
2491
        if (size == 0)
2492
            _Py_RETURN_UNICODE_EMPTY();
inline
            
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_FromWideChar
inline
            
PyUnicode_New will not be inlined into PyUnicode_FromWideChar 
PyUnicode_FromWideChar
gvn
            
load of type %struct._object* eliminated in favor of phi 
PyUnicode_FromWideChar
inline
            
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_EncodeLocale
inline
            
PyUnicode_New will not be inlined into PyUnicode_EncodeLocale 
PyUnicode_EncodeLocale
inline
            
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_DecodeLocaleAndSize
inline
            
PyUnicode_New will not be inlined into PyUnicode_DecodeLocaleAndSize 
PyUnicode_DecodeLocaleAndSize
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeLocaleAndSize
2493
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into PyUnicode_FromWideChar because its definition is unavailable 
PyUnicode_FromWideChar
2494
        return NULL;
2495
    }
2496
2497
    if (size == -1) {
2498
        size = wcslen(w);
inline
               
wcslen will not be inlined into PyUnicode_FromWideChar because its definition is unavailable 
PyUnicode_FromWideChar
2499
    }
2500
2501
    return PyUnicode_FromUnicode(w, size);
inline
           
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_FromWideChar
inline
           
PyUnicode_FromUnicode will not be inlined into PyUnicode_FromWideChar 
PyUnicode_FromWideChar
inline
           
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeLocale
inline
           
PyUnicode_FromUnicode will not be inlined into PyUnicode_EncodeLocale 
PyUnicode_EncodeLocale
inline
           
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeLocaleAndSize
inline
           
PyUnicode_FromUnicode will not be inlined into PyUnicode_DecodeLocaleAndSize 
PyUnicode_DecodeLocaleAndSize
2502
}
2503
2504
#endif /* HAVE_WCHAR_H */
2505
2506
/* maximum number of characters required for output of %lld or %p.
2507
   We need at most ceil(log10(256)*SIZEOF_LONG_LONG) digits,
2508
   plus 1 for the sign.  53/22 is an upper bound for log10(256). */
2509
#define MAX_LONG_LONG_CHARS (2 + (SIZEOF_LONG_LONG*53-1) / 22)
2510
2511
static int
2512
unicode_fromformat_write_str(_PyUnicodeWriter *writer, PyObject *str,
2513
                             Py_ssize_t width, Py_ssize_t precision)
2514
{
2515
    Py_ssize_t length, fill, arglen;
2516
    Py_UCS4 maxchar;
2517
2518
    if (PyUnicode_READY(str) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_fromformat_write_str
inline
        
_PyUnicode_Ready will not be inlined into unicode_fromformat_write_str 
unicode_fromformat_write_str
2519
        return -1;
2520
2521
    length = PyUnicode_GET_LENGTH(str);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_write_str
2522
    if ((precision == -1 || precision >= length)
2523
        && width <= length)
2524
        return _PyUnicodeWriter_WriteStr(writer, str);
inline
               
_PyUnicodeWriter_WriteStr too costly to inline (cost=445, threshold=250) 
unicode_fromformat_write_str
inline
               
_PyUnicodeWriter_WriteStr will not be inlined into unicode_fromformat_write_str 
unicode_fromformat_write_str
2525
2526
    if (precision != -1)
2527
        length = Py_MIN(precision, length);
2528
2529
    arglen = Py_MAX(length, width);
2530
    if (PyUnicode_MAX_CHAR_VALUE(str) > writer->maxchar)
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_fromformat_write_str
gvn
                                                
load of type i32 not eliminated because it is clobbered by call 
unicode_fromformat_write_str
2531
        maxchar = _PyUnicode_FindMaxChar(str, 0, length);
inline
                  
_PyUnicode_FindMaxChar too costly to inline (cost=600, threshold=250) 
unicode_fromformat_write_str
inline
                  
_PyUnicode_FindMaxChar will not be inlined into unicode_fromformat_write_str 
unicode_fromformat_write_str
2532
    else
2533
        maxchar = writer->maxchar;
2534
2535
    if (_PyUnicodeWriter_Prepare(writer, arglen, maxchar) == -1)
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
unicode_fromformat_write_str
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into unicode_fromformat_write_str 
unicode_fromformat_write_str
gvn
        
load of type i32 eliminated in favor of load 
unicode_fromformat_write_str
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_write_str
2536
        return -1;
2537
2538
    if (width > length) {
2539
        fill = width - length;
2540
        if (PyUnicode_Fill(writer->buffer, writer->pos, fill, ' ') == -1)
inline
            
PyUnicode_Fill too costly to inline (cost=485, threshold=250) 
unicode_fromformat_write_str
inline
            
PyUnicode_Fill will not be inlined into unicode_fromformat_write_str 
unicode_fromformat_write_str
gvn
                                   
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_write_str
gvn
                                   
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_write_str
gvn
                                                   
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_write_str
gvn
                                                   
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_write_str
2541
            return -1;
2542
        writer->pos += fill;
gvn
                    
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_fromformat_write_str
2543
    }
2544
2545
    _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos,
inline
    
_PyUnicode_FastCopyCharacters can be inlined into unicode_fromformat_write_str with cost=5 (threshold=375) 
unicode_fromformat_write_str
inline
    
_PyUnicode_FastCopyCharacters inlined into unicode_fromformat_write_str 
unicode_fromformat_write_str
gvn
                                          
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_write_str
gvn
                                          
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_write_str
gvn
                                          
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_write_str
gvn
                                                          
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_write_str
gvn
                                                          
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_write_str
gvn
                                                          
load eliminated by PRE 
unicode_fromformat_write_str
2546
                                  str, 0, length);
2547
    writer->pos += length;
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_write_str
2548
    return 0;
2549
}
2550
2551
static int
2552
unicode_fromformat_write_cstr(_PyUnicodeWriter *writer, const char *str,
2553
                              Py_ssize_t width, Py_ssize_t precision)
2554
{
2555
    /* UTF-8 */
2556
    Py_ssize_t length;
2557
    PyObject *unicode;
2558
    int res;
2559
2560
    length = strlen(str);
inline
             
strlen will not be inlined into unicode_fromformat_write_cstr because its definition is unavailable 
unicode_fromformat_write_cstr
2561
    if (precision != -1)
2562
        length = Py_MIN(length, precision);
2563
    unicode = PyUnicode_DecodeUTF8Stateful(str, length, "replace", NULL);
inline
              
PyUnicode_DecodeUTF8Stateful too costly to inline (cost=630, threshold=625) 
unicode_fromformat_write_cstr
inline
              
PyUnicode_DecodeUTF8Stateful will not be inlined into unicode_fromformat_write_cstr 
unicode_fromformat_write_cstr
inline
              
PyUnicode_DecodeUTF8Stateful too costly to inline (cost=630, threshold=625) 
unicode_fromformat_arg
inline
              
PyUnicode_DecodeUTF8Stateful will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
inline
              
PyUnicode_DecodeUTF8Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_FromFormatV
inline
              
PyUnicode_DecodeUTF8Stateful will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2564
    if (unicode == NULL)
2565
        return -1;
2566
2567
    res = unicode_fromformat_write_str(writer, unicode, width, -1);
inline
          
unicode_fromformat_write_str too costly to inline (cost=500, threshold=250) 
unicode_fromformat_write_cstr
inline
          
unicode_fromformat_write_str will not be inlined into unicode_fromformat_write_cstr 
unicode_fromformat_write_cstr
inline
          
unicode_fromformat_write_str too costly to inline (cost=500, threshold=250) 
unicode_fromformat_arg
inline
          
unicode_fromformat_write_str will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
inline
          
unicode_fromformat_write_str too costly to inline (cost=500, threshold=250) 
PyUnicode_FromFormatV
inline
          
unicode_fromformat_write_str will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2568
    Py_DECREF(unicode);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_write_cstr
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_fromformat_write_cstr
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2569
    return res;
2570
}
2571
2572
static const char*
2573
unicode_fromformat_arg(_PyUnicodeWriter *writer,
2574
                       const char *f, va_list *vargs)
2575
{
2576
    const char *p;
2577
    Py_ssize_t len;
2578
    int zeropad;
2579
    Py_ssize_t width;
2580
    Py_ssize_t precision;
2581
    int longflag;
2582
    int longlongflag;
2583
    int size_tflag;
2584
    Py_ssize_t fill;
2585
2586
    p = f;
2587
    f++;
2588
    zeropad = 0;
2589
    if (*f == '0') {
2590
        zeropad = 1;
2591
        f++;
2592
    }
2593
2594
    /* parse the width.precision part, e.g. "%2.5s" => width=2, precision=5 */
2595
    width = -1;
2596
    if (Py_ISDIGIT((unsigned)*f)) {
2597
        width = *f - '0';
2598
        f++;
2599
        while (Py_ISDIGIT((unsigned)*f)) {
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_FromFormatV
loop-vectorize
        
loop not vectorized 
PyUnicode_FromFormatV
2600
            if (width > (PY_SSIZE_T_MAX - ((int)*f - '0')) / 10) {
2601
                PyErr_SetString(PyExc_ValueError,
inline
                
PyErr_SetString will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2602
                                "width too big");
2603
                return NULL;
2604
            }
2605
            width = (width * 10) + (*f - '0');
2606
            f++;
2607
        }
2608
    }
2609
    precision = -1;
2610
    if (*f == '.') {
gvn
        
load of type i8 eliminated in favor of phi 
unicode_fromformat_arg
2611
        f++;
2612
        if (Py_ISDIGIT((unsigned)*f)) {
2613
            precision = (*f - '0');
2614
            f++;
2615
            while (Py_ISDIGIT((unsigned)*f)) {
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_FromFormatV
loop-vectorize
            
loop not vectorized 
PyUnicode_FromFormatV
2616
                if (precision > (PY_SSIZE_T_MAX - ((int)*f - '0')) / 10) {
2617
                    PyErr_SetString(PyExc_ValueError,
inline
                    
PyErr_SetString will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2618
                                    "precision too big");
2619
                    return NULL;
2620
                }
2621
                precision = (precision * 10) + (*f - '0');
2622
                f++;
2623
            }
2624
        }
2625
        if (*f == '%') {
gvn
            
load of type i8 eliminated in favor of phi 
unicode_fromformat_arg
2626
            /* "%.3%s" => f points to "3" */
2627
            f--;
2628
        }
2629
    }
2630
    if (*f == '\0') {
gvn
        
load eliminated by PRE 
unicode_fromformat_arg
2631
        /* bogus format "%.123" => go backward, f points to "3" */
2632
        f--;
2633
    }
2634
2635
    /* Handle %ld, %lu, %lld and %llu. */
2636
    longflag = 0;
2637
    longlongflag = 0;
2638
    size_tflag = 0;
2639
    if (*f == 'l') {
2640
        if (f[1] == 'd' || f[1] == 'u' || f[1] == 'i') {
2641
            longflag = 1;
2642
            ++f;
2643
        }
2644
        else if (f[1] == 'l' &&
2645
                 (f[2] == 'd' || f[2] == 'u' || f[2] == 'i')) {
2646
            longlongflag = 1;
2647
            f += 2;
2648
        }
2649
    }
2650
    /* handle the size_t flag. */
2651
    else if (*f == 'z' && (f[1] == 'd' || f[1] == 'u' || f[1] == 'i')) {
2652
        size_tflag = 1;
2653
        ++f;
2654
    }
2655
2656
    if (f[1] == '\0')
2657
        writer->overallocate = 0;
2658
2659
    switch (*f) {
gvn
            
load of type i8 not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
            
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
2660
    case 'c':
2661
    {
2662
        int ordinal = va_arg(*vargs, int);
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
                      
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                      
hosting getelementptr 
PyUnicode_FromFormatV
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2663
        if (ordinal < 0 || ordinal > MAX_UNICODE) {
2664
            PyErr_SetString(PyExc_OverflowError,
inline
            
PyErr_SetString will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2665
                            "character argument not in range(0x110000)");
2666
            return NULL;
2667
        }
2668
        if (_PyUnicodeWriter_WriteCharInline(writer, ordinal) < 0)
inline
            
_PyUnicodeWriter_WriteCharInline can be inlined into unicode_fromformat_arg with cost=150 (threshold=325) 
unicode_fromformat_arg
inline
            
_PyUnicodeWriter_WriteCharInline inlined into unicode_fromformat_arg 
unicode_fromformat_arg
2669
            return NULL;
2670
        break;
2671
    }
2672
2673
    case 'i':
2674
    case 'd':
2675
    case 'u':
2676
    case 'x':
2677
    {
2678
        /* used by sprintf */
2679
        char buffer[MAX_LONG_LONG_CHARS];
licm
        
hosting getelementptr 
PyUnicode_FromFormatV
2680
        Py_ssize_t arglen;
2681
2682
        if (*f == 'u') {
gvn
            
load of type i8 eliminated in favor of load 
unicode_fromformat_arg
2683
            if (longflag)
2684
                len = sprintf(buffer, "%lu",
inline
                      
sprintf will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
2685
                        va_arg(*vargs, unsigned long));
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2686
            else if (longlongflag)
2687
                len = sprintf(buffer, "%llu",
inline
                      
sprintf will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
2688
                        va_arg(*vargs, unsigned long long));
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2689
            else if (size_tflag)
2690
                len = sprintf(buffer, "%" PY_FORMAT_SIZE_T "u",
inline
                      
sprintf will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
2691
                        va_arg(*vargs, size_t));
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2692
            else
2693
                len = sprintf(buffer, "%u",
inline
                      
sprintf will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
2694
                        va_arg(*vargs, unsigned int));
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2695
        }
2696
        else if (*f == 'x') {
2697
            len = sprintf(buffer, "%x", va_arg(*vargs, int));
inline
                  
sprintf will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
gvn
                                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2698
        }
2699
        else {
2700
            if (longflag)
2701
                len = sprintf(buffer, "%li",
inline
                      
sprintf will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
2702
                        va_arg(*vargs, long));
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2703
            else if (longlongflag)
2704
                len = sprintf(buffer, "%lli",
inline
                      
sprintf will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
2705
                        va_arg(*vargs, long long));
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2706
            else if (size_tflag)
2707
                len = sprintf(buffer, "%" PY_FORMAT_SIZE_T "i",
inline
                      
sprintf will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
2708
                        va_arg(*vargs, Py_ssize_t));
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2709
            else
2710
                len = sprintf(buffer, "%i",
inline
                      
sprintf will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
2711
                        va_arg(*vargs, int));
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2712
        }
2713
        assert(len >= 0);
2714
2715
        if (precision < len)
2716
            precision = len;
2717
2718
        arglen = Py_MAX(precision, width);
2719
        if (_PyUnicodeWriter_Prepare(writer, arglen, 127) == -1)
inline
            
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
unicode_fromformat_arg
inline
            
_PyUnicodeWriter_PrepareInternal will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
inline
            
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_FromFormatV
inline
            
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
licm
            
hosting getelementptr 
PyUnicode_FromFormatV
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2720
            return NULL;
2721
2722
        if (width > precision) {
2723
            Py_UCS4 fillchar;
2724
            fill = width - precision;
2725
            fillchar = zeropad?'0':' ';
2726
            if (PyUnicode_Fill(writer->buffer, writer->pos, fill, fillchar) == -1)
inline
                
PyUnicode_Fill too costly to inline (cost=485, threshold=250) 
unicode_fromformat_arg
inline
                
PyUnicode_Fill will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
inline
                
PyUnicode_Fill too costly to inline (cost=485, threshold=250) 
PyUnicode_FromFormatV
inline
                
PyUnicode_Fill will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
licm
                                       
hosting getelementptr 
PyUnicode_FromFormatV
licm
                                       
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
licm
                                                       
hosting getelementptr 
PyUnicode_FromFormatV
licm
                                                       
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2727
                return NULL;
2728
            writer->pos += fill;
gvn
                        
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_fromformat_arg
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i64 not eliminated in favor of load because it is clobbered by call 
PyUnicode_FromFormatV
2729
        }
2730
        if (precision > len) {
2731
            fill = precision - len;
2732
            if (PyUnicode_Fill(writer->buffer, writer->pos, fill, '0') == -1)
inline
                
PyUnicode_Fill too costly to inline (cost=485, threshold=250) 
unicode_fromformat_arg
inline
                
PyUnicode_Fill will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
inline
                
PyUnicode_Fill too costly to inline (cost=485, threshold=250) 
PyUnicode_FromFormatV
inline
                
PyUnicode_Fill will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
licm
                                       
hosting getelementptr 
PyUnicode_FromFormatV
licm
                                       
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
licm
                                                       
hosting getelementptr 
PyUnicode_FromFormatV
licm
                                                       
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2733
                return NULL;
2734
            writer->pos += fill;
gvn
                        
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_fromformat_arg
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i64 not eliminated in favor of load because it is clobbered by call 
PyUnicode_FromFormatV
2735
        }
2736
2737
        if (_PyUnicodeWriter_WriteASCIIString(writer, buffer, len) < 0)
inline
            
_PyUnicodeWriter_WriteASCIIString too costly to inline (cost=630, threshold=625) 
unicode_fromformat_arg
inline
            
_PyUnicodeWriter_WriteASCIIString will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
inline
            
_PyUnicodeWriter_WriteASCIIString too costly to inline (cost=630, threshold=625) 
PyUnicode_FromFormatV
inline
            
_PyUnicodeWriter_WriteASCIIString will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2738
            return NULL;
2739
        break;
2740
    }
2741
2742
    case 'p':
2743
    {
2744
        char number[MAX_LONG_LONG_CHARS];
licm
        
hosting getelementptr 
PyUnicode_FromFormatV
2745
2746
        len = sprintf(number, "%p", va_arg(*vargs, void*));
inline
              
sprintf will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
gvn
                                    
load of type i32 not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
                                    
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                                    
hosting getelementptr 
PyUnicode_FromFormatV
licm
                                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2747
        assert(len >= 0);
2748
2749
        /* %p is ill-defined:  ensure leading 0x. */
2750
        if (number[1] == 'X')
gvn
            
load of type i8 not eliminated because it is clobbered by call 
unicode_fromformat_arg
licm
            
hosting getelementptr 
PyUnicode_FromFormatV
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
            
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2751
            number[1] = 'x';
2752
        else if (number[1] != 'x') {
2753
            memmove(number + 2, number,
licm
                           
hosting getelementptr 
PyUnicode_FromFormatV
2754
                    strlen(number) + 1);
inline
                    
strlen will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
2755
            number[0] = '0';
2756
            number[1] = 'x';
2757
            len += 2;
2758
        }
2759
2760
        if (_PyUnicodeWriter_WriteASCIIString(writer, number, len) < 0)
inline
            
_PyUnicodeWriter_WriteASCIIString too costly to inline (cost=630, threshold=625) 
unicode_fromformat_arg
inline
            
_PyUnicodeWriter_WriteASCIIString will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
inline
            
_PyUnicodeWriter_WriteASCIIString too costly to inline (cost=630, threshold=625) 
PyUnicode_FromFormatV
inline
            
_PyUnicodeWriter_WriteASCIIString will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2761
            return NULL;
2762
        break;
2763
    }
2764
2765
    case 's':
2766
    {
2767
        /* UTF-8 */
2768
        const char *s = va_arg(*vargs, const char*);
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2769
        if (unicode_fromformat_write_cstr(writer, s, width, precision) < 0)
inline
            
unicode_fromformat_write_cstr can be inlined into unicode_fromformat_arg with cost=160 (threshold=250) 
unicode_fromformat_arg
inline
            
unicode_fromformat_write_cstr inlined into unicode_fromformat_arg 
unicode_fromformat_arg
2770
            return NULL;
2771
        break;
2772
    }
2773
2774
    case 'U':
2775
    {
2776
        PyObject *obj = va_arg(*vargs, PyObject *);
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2777
        assert(obj && _PyUnicode_CHECK(obj));
2778
2779
        if (unicode_fromformat_write_str(writer, obj, width, precision) == -1)
inline
            
unicode_fromformat_write_str too costly to inline (cost=520, threshold=250) 
unicode_fromformat_arg
inline
            
unicode_fromformat_write_str will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
inline
            
unicode_fromformat_write_str too costly to inline (cost=520, threshold=250) 
PyUnicode_FromFormatV
inline
            
unicode_fromformat_write_str will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2780
            return NULL;
2781
        break;
2782
    }
2783
2784
    case 'V':
2785
    {
2786
        PyObject *obj = va_arg(*vargs, PyObject *);
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
2787
        const char *str = va_arg(*vargs, const char *);
gvn
                          
load of type i32 eliminated in favor of load 
unicode_fromformat_arg
gvn
                          
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
licm
                          
hosting getelementptr 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                          
load eliminated by PRE 
PyUnicode_FromFormatV
gvn
                          
load of type i8* eliminated in favor of load 
PyUnicode_FromFormatV
2788
        if (obj) {
2789
            assert(_PyUnicode_CHECK(obj));
2790
            if (unicode_fromformat_write_str(writer, obj, width, precision) == -1)
inline
                
unicode_fromformat_write_str too costly to inline (cost=520, threshold=250) 
unicode_fromformat_arg
inline
                
unicode_fromformat_write_str will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
inline
                
unicode_fromformat_write_str too costly to inline (cost=520, threshold=250) 
PyUnicode_FromFormatV
inline
                
unicode_fromformat_write_str will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2791
                return NULL;
2792
        }
2793
        else {
2794
            assert(str != NULL);
2795
            if (unicode_fromformat_write_cstr(writer, str, width, precision) < 0)
inline
                
unicode_fromformat_write_cstr can be inlined into unicode_fromformat_arg with cost=-14840 (threshold=250) 
unicode_fromformat_arg
inline
                
unicode_fromformat_write_cstr inlined into unicode_fromformat_arg 
unicode_fromformat_arg
2796
                return NULL;
2797
        }
2798
        break;
2799
    }
2800
2801
    case 'S':
2802
    {
2803
        PyObject *obj = va_arg(*vargs, PyObject *);
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2804
        PyObject *str;
2805
        assert(obj);
2806
        str = PyObject_Str(obj);
inline
              
PyObject_Str will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
2807
        if (!str)
2808
            return NULL;
2809
        if (unicode_fromformat_write_str(writer, str, width, precision) == -1) {
inline
            
unicode_fromformat_write_str too costly to inline (cost=520, threshold=250) 
unicode_fromformat_arg
inline
            
unicode_fromformat_write_str will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
inline
            
unicode_fromformat_write_str too costly to inline (cost=520, threshold=250) 
PyUnicode_FromFormatV
inline
            
unicode_fromformat_write_str will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2810
            Py_DECREF(str);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2811
            return NULL;
2812
        }
2813
        Py_DECREF(str);
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2814
        break;
2815
    }
2816
2817
    case 'R':
2818
    {
2819
        PyObject *obj = va_arg(*vargs, PyObject *);
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2820
        PyObject *repr;
2821
        assert(obj);
2822
        repr = PyObject_Repr(obj);
inline
               
PyObject_Repr will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
2823
        if (!repr)
2824
            return NULL;
2825
        if (unicode_fromformat_write_str(writer, repr, width, precision) == -1) {
inline
            
unicode_fromformat_write_str too costly to inline (cost=520, threshold=250) 
unicode_fromformat_arg
inline
            
unicode_fromformat_write_str will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
inline
            
unicode_fromformat_write_str too costly to inline (cost=520, threshold=250) 
PyUnicode_FromFormatV
inline
            
unicode_fromformat_write_str will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2826
            Py_DECREF(repr);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2827
            return NULL;
2828
        }
2829
        Py_DECREF(repr);
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2830
        break;
2831
    }
2832
2833
    case 'A':
2834
    {
2835
        PyObject *obj = va_arg(*vargs, PyObject *);
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
                        
hosting getelementptr 
PyUnicode_FromFormatV
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2836
        PyObject *ascii;
2837
        assert(obj);
2838
        ascii = PyObject_ASCII(obj);
inline
                
PyObject_ASCII will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
2839
        if (!ascii)
2840
            return NULL;
2841
        if (unicode_fromformat_write_str(writer, ascii, width, precision) == -1) {
inline
            
unicode_fromformat_write_str too costly to inline (cost=520, threshold=250) 
unicode_fromformat_arg
inline
            
unicode_fromformat_write_str will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
inline
            
unicode_fromformat_write_str too costly to inline (cost=520, threshold=250) 
PyUnicode_FromFormatV
inline
            
unicode_fromformat_write_str will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2842
            Py_DECREF(ascii);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2843
            return NULL;
2844
        }
2845
        Py_DECREF(ascii);
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2846
        break;
2847
    }
2848
2849
    case '%':
2850
        if (_PyUnicodeWriter_WriteCharInline(writer, '%') < 0)
inline
            
_PyUnicodeWriter_WriteCharInline can be inlined into unicode_fromformat_arg with cost=150 (threshold=325) 
unicode_fromformat_arg
inline
            
_PyUnicodeWriter_WriteCharInline inlined into unicode_fromformat_arg 
unicode_fromformat_arg
2851
            return NULL;
2852
        break;
2853
2854
    default:
2855
        /* if we stumble upon an unknown formatting code, copy the rest
2856
           of the format string to the output string. (we cannot just
2857
           skip the code, since there's no way to know what's in the
2858
           argument list) */
2859
        len = strlen(p);
inline
              
strlen will not be inlined into unicode_fromformat_arg because its definition is unavailable 
unicode_fromformat_arg
2860
        if (_PyUnicodeWriter_WriteLatin1String(writer, p, len) == -1)
inline
            
_PyUnicodeWriter_WriteLatin1String too costly to inline (cost=345, threshold=250) 
unicode_fromformat_arg
inline
            
_PyUnicodeWriter_WriteLatin1String will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
inline
            
_PyUnicodeWriter_WriteLatin1String too costly to inline (cost=345, threshold=250) 
PyUnicode_FromFormatV
inline
            
_PyUnicodeWriter_WriteLatin1String will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2861
            return NULL;
2862
        f = p+len;
2863
        return f;
2864
    }
2865
2866
    f++;
2867
    return f;
2868
}
2869
2870
PyObject *
2871
PyUnicode_FromFormatV(const char *format, va_list vargs)
2872
{
2873
    va_list vargs2;
2874
    const char *f;
2875
    _PyUnicodeWriter writer;
2876
2877
    _PyUnicodeWriter_Init(&writer);
inline
    
_PyUnicodeWriter_Init can be inlined into PyUnicode_FromFormatV with cost=-30 (threshold=375) 
PyUnicode_FromFormatV
inline
    
_PyUnicodeWriter_Init inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2878
    writer.min_length = strlen(format) + 100;
inline
                        
strlen will not be inlined into PyUnicode_FromFormatV because its definition is unavailable 
PyUnicode_FromFormatV
2879
    writer.overallocate = 1;
2880
2881
    // Copy varags to be able to pass a reference to a subfunction.
2882
    va_copy(vargs2, vargs);
2883
2884
    for (f = format; *f; ) {
gvn
                     
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                     
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2885
        if (*f == '%') {
2886
            f = unicode_fromformat_arg(&writer, f, &vargs2);
inline
                
unicode_fromformat_arg can be inlined into PyUnicode_FromFormatV with cost=-11230 (threshold=250) 
PyUnicode_FromFormatV
inline
                
unicode_fromformat_arg inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2887
            if (f == NULL)
2888
                goto fail;
2889
        }
2890
        else {
2891
            const char *p;
loop-vectorize
                        
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_FromFormatV
loop-vectorize
                        
loop not vectorized 
PyUnicode_FromFormatV
2892
            Py_ssize_t len;
2893
2894
            p = f;
2895
            do
2896
            {
2897
                if ((unsigned char)*p > 127) {
gvn
                                   
load of type i8 eliminated in favor of phi 
PyUnicode_FromFormatV
2898
                    PyErr_Format(PyExc_ValueError,
inline
                    
PyErr_Format will not be inlined into PyUnicode_FromFormatV because its definition is unavailable 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
2899
                        "PyUnicode_FromFormatV() expects an ASCII-encoded format "
2900
                        "string, got a non-ASCII byte: 0x%02x",
2901
                        (unsigned char)*p);
2902
                    goto fail;
2903
                }
2904
                p++;
2905
            }
2906
            while (*p != '\0' && *p != '%');
2907
            len = p - f;
2908
2909
            if (*p == '\0')
2910
                writer.overallocate = 0;
2911
2912
            if (_PyUnicodeWriter_WriteASCIIString(&writer, f, len) < 0)
inline
                
_PyUnicodeWriter_WriteASCIIString too costly to inline (cost=630, threshold=625) 
PyUnicode_FromFormatV
inline
                
_PyUnicodeWriter_WriteASCIIString will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2913
                goto fail;
2914
2915
            f = p;
2916
        }
2917
    }
2918
    va_end(vargs2);
2919
    return _PyUnicodeWriter_Finish(&writer);
inline
           
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
PyUnicode_FromFormatV
inline
           
_PyUnicodeWriter_Finish will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2920
2921
  fail:
2922
    va_end(vargs2);
2923
    _PyUnicodeWriter_Dealloc(&writer);
inline
    
_PyUnicodeWriter_Dealloc can be inlined into PyUnicode_FromFormatV with cost=20 (threshold=250) 
PyUnicode_FromFormatV
inline
    
_PyUnicodeWriter_Dealloc inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
2924
    return NULL;
2925
}
2926
2927
PyObject *
2928
PyUnicode_FromFormat(const char *format, ...)
2929
{
2930
    PyObject* ret;
2931
    va_list vargs;
2932
2933
#ifdef HAVE_STDARG_PROTOTYPES
2934
    va_start(vargs, format);
2935
#else
2936
    va_start(vargs);
2937
#endif
2938
    ret = PyUnicode_FromFormatV(format, vargs);
inline
          
PyUnicode_FromFormatV too costly to inline (cost=665, threshold=625) 
PyUnicode_FromFormat
inline
          
PyUnicode_FromFormatV will not be inlined into PyUnicode_FromFormat 
PyUnicode_FromFormat
2939
    va_end(vargs);
2940
    return ret;
2941
}
2942
2943
#ifdef HAVE_WCHAR_H
2944
2945
/* Helper function for PyUnicode_AsWideChar() and PyUnicode_AsWideCharString():
2946
   convert a Unicode object to a wide character string.
2947
2948
   - If w is NULL: return the number of wide characters (including the null
2949
     character) required to convert the unicode object. Ignore size argument.
2950
2951
   - Otherwise: return the number of wide characters (excluding the null
2952
     character) written into w. Write at most size wide characters (including
2953
     the null character). */
2954
static Py_ssize_t
2955
unicode_aswidechar(PyObject *unicode,
2956
                   wchar_t *w,
2957
                   Py_ssize_t size)
2958
{
2959
    Py_ssize_t res;
2960
    const wchar_t *wstr;
2961
2962
    wstr = PyUnicode_AsUnicodeAndSize(unicode, &res);
inline
           
PyUnicode_AsUnicodeAndSize too costly to inline (cost=440, threshold=250) 
unicode_aswidechar
inline
           
PyUnicode_AsUnicodeAndSize will not be inlined into unicode_aswidechar 
unicode_aswidechar
inline
           
PyUnicode_AsUnicodeAndSize too costly to inline (cost=440, threshold=250) 
PyUnicode_AsWideChar
inline
           
PyUnicode_AsUnicodeAndSize will not be inlined into PyUnicode_AsWideChar 
PyUnicode_AsWideChar
inline
           
PyUnicode_AsUnicodeAndSize too costly to inline (cost=440, threshold=250) 
PyUnicode_AsWideCharString
inline
           
PyUnicode_AsUnicodeAndSize will not be inlined into PyUnicode_AsWideCharString 
PyUnicode_AsWideCharString
2963
    if (wstr == NULL)
2964
        return -1;
2965
2966
    if (w != NULL) {
2967
        if (size > res)
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
unicode_aswidechar
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsWideChar
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsWideCharString
2968
            size = res + 1;
2969
        else
2970
            res = size;
2971
        memcpy(w, wstr, size * sizeof(wchar_t));
2972
        return res;
gvn
               
load of type i64 eliminated in favor of phi 
unicode_aswidechar
2973
    }
2974
    else
2975
        return res + 1;
2976
}
2977
2978
Py_ssize_t
2979
PyUnicode_AsWideChar(PyObject *unicode,
2980
                     wchar_t *w,
2981
                     Py_ssize_t size)
2982
{
2983
    if (unicode == NULL) {
2984
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into PyUnicode_AsWideChar because its definition is unavailable 
PyUnicode_AsWideChar
2985
        return -1;
2986
    }
2987
    return unicode_aswidechar(unicode, w, size);
inline
           
unicode_aswidechar can be inlined into PyUnicode_AsWideChar with cost=60 (threshold=250) 
PyUnicode_AsWideChar
inline
           
unicode_aswidechar inlined into PyUnicode_AsWideChar 
PyUnicode_AsWideChar
2988
}
2989
2990
wchar_t*
2991
PyUnicode_AsWideCharString(PyObject *unicode,
2992
                           Py_ssize_t *size)
2993
{
2994
    wchar_t* buffer;
2995
    Py_ssize_t buflen;
2996
2997
    if (unicode == NULL) {
2998
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into PyUnicode_AsWideCharString because its definition is unavailable 
PyUnicode_AsWideCharString
2999
        return NULL;
3000
    }
3001
3002
    buflen = unicode_aswidechar(unicode, NULL, 0);
inline
             
unicode_aswidechar can be inlined into PyUnicode_AsWideCharString with cost=20 (threshold=250) 
PyUnicode_AsWideCharString
inline
             
unicode_aswidechar inlined into PyUnicode_AsWideCharString 
PyUnicode_AsWideCharString
3003
    if (buflen == -1)
3004
        return NULL;
3005
    buffer = PyMem_NEW(wchar_t, buflen);
inline
             
PyMem_Malloc will not be inlined into PyUnicode_AsWideCharString because its definition is unavailable 
PyUnicode_AsWideCharString
3006
    if (buffer == NULL) {
3007
        PyErr_NoMemory();
inline
        
PyErr_NoMemory will not be inlined into PyUnicode_AsWideCharString because its definition is unavailable 
PyUnicode_AsWideCharString
3008
        return NULL;
3009
    }
3010
    buflen = unicode_aswidechar(unicode, buffer, buflen);
inline
             
unicode_aswidechar can be inlined into PyUnicode_AsWideCharString with cost=-14955 (threshold=250) 
PyUnicode_AsWideCharString
inline
             
unicode_aswidechar inlined into PyUnicode_AsWideCharString 
PyUnicode_AsWideCharString
3011
    if (buflen == -1) {
3012
        PyMem_FREE(buffer);
inline
        
PyMem_Free will not be inlined into PyUnicode_AsWideCharString because its definition is unavailable 
PyUnicode_AsWideCharString
3013
        return NULL;
3014
    }
3015
    if (size != NULL)
3016
        *size = buflen;
3017
    return buffer;
3018
}
3019
3020
#endif /* HAVE_WCHAR_H */
3021
3022
PyObject *
3023
PyUnicode_FromOrdinal(int ordinal)
3024
{
3025
    if (ordinal < 0 || ordinal > MAX_UNICODE) {
3026
        PyErr_SetString(PyExc_ValueError,
inline
        
PyErr_SetString will not be inlined into PyUnicode_FromOrdinal because its definition is unavailable 
PyUnicode_FromOrdinal
3027
                        "chr() arg not in range(0x110000)");
3028
        return NULL;
3029
    }
3030
3031
    return unicode_char((Py_UCS4)ordinal);
inline
           
unicode_char can be inlined into PyUnicode_FromOrdinal with cost=205 (threshold=250) 
PyUnicode_FromOrdinal
inline
           
unicode_char inlined into PyUnicode_FromOrdinal 
PyUnicode_FromOrdinal
3032
}
3033
3034
PyObject *
3035
PyUnicode_FromObject(PyObject *obj)
3036
{
3037
    /* XXX Perhaps we should make this API an alias of
3038
       PyObject_Str() instead ?! */
3039
    if (PyUnicode_CheckExact(obj)) {
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Concat
3040
        if (PyUnicode_READY(obj) == -1)
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_FromObject
inline
            
_PyUnicode_Ready will not be inlined into PyUnicode_FromObject 
PyUnicode_FromObject
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_TranslateCharmap
inline
            
_PyUnicode_Ready will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
gvn
            
load of type i32 eliminated in favor of phi 
_PyUnicode_TranslateCharmap
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Concat
inline
            
_PyUnicode_Ready will not be inlined into PyUnicode_Concat 
PyUnicode_Concat
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Concat
3041
            return NULL;
3042
        Py_INCREF(obj);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromObject
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Concat
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Concat
3043
        return obj;
3044
    }
3045
    if (PyUnicode_Check(obj)) {
3046
        /* For a Unicode subtype that's not a Unicode object,
3047
           return a true Unicode object with the same data. */
3048
        return _PyUnicode_Copy(obj);
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
PyUnicode_FromObject
inline
               
_PyUnicode_Copy will not be inlined into PyUnicode_FromObject 
PyUnicode_FromObject
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
_PyUnicode_TranslateCharmap
inline
               
_PyUnicode_Copy will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
inline
               
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
PyUnicode_Concat
inline
               
_PyUnicode_Copy will not be inlined into PyUnicode_Concat 
PyUnicode_Concat
3049
    }
3050
    PyErr_Format(PyExc_TypeError,
inline
    
PyErr_Format will not be inlined into PyUnicode_FromObject because its definition is unavailable 
PyUnicode_FromObject
gvn
                 
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Concat
3051
                 "Can't convert '%.100s' object to str implicitly",
3052
                 Py_TYPE(obj)->tp_name);
3053
    return NULL;
3054
}
3055
3056
PyObject *
3057
PyUnicode_FromEncodedObject(PyObject *obj,
3058
                            const char *encoding,
3059
                            const char *errors)
3060
{
3061
    Py_buffer buffer;
3062
    PyObject *v;
3063
3064
    if (obj == NULL) {
3065
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into PyUnicode_FromEncodedObject because its definition is unavailable 
PyUnicode_FromEncodedObject
3066
        return NULL;
3067
    }
3068
3069
    /* Decoding bytes objects is the most common case and should be fast */
3070
    if (PyBytes_Check(obj)) {
3071
        if (PyBytes_GET_SIZE(obj) == 0)
3072
            _Py_RETURN_UNICODE_EMPTY();
inline
            
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_FromEncodedObject
inline
            
PyUnicode_New will not be inlined into PyUnicode_FromEncodedObject 
PyUnicode_FromEncodedObject
gvn
            
load of type %struct._object* eliminated in favor of phi 
PyUnicode_FromEncodedObject
3073
        v = PyUnicode_Decode(
inline
            
PyUnicode_Decode too costly to inline (cost=630, threshold=625) 
PyUnicode_FromEncodedObject
inline
            
PyUnicode_Decode will not be inlined into PyUnicode_FromEncodedObject 
PyUnicode_FromEncodedObject
3074
                PyBytes_AS_STRING(obj), PyBytes_GET_SIZE(obj),
3075
                encoding, errors);
3076
        return v;
3077
    }
3078
3079
    if (PyUnicode_Check(obj)) {
3080
        PyErr_SetString(PyExc_TypeError,
inline
        
PyErr_SetString will not be inlined into PyUnicode_FromEncodedObject because its definition is unavailable 
PyUnicode_FromEncodedObject
3081
                        "decoding str is not supported");
3082
        return NULL;
3083
    }
3084
3085
    /* Retrieve a bytes buffer view through the PEP 3118 buffer interface */
3086
    if (PyObject_GetBuffer(obj, &buffer, PyBUF_SIMPLE) < 0) {
inline
        
PyObject_GetBuffer will not be inlined into PyUnicode_FromEncodedObject because its definition is unavailable 
PyUnicode_FromEncodedObject
3087
        PyErr_Format(PyExc_TypeError,
inline
        
PyErr_Format will not be inlined into PyUnicode_FromEncodedObject because its definition is unavailable 
PyUnicode_FromEncodedObject
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromEncodedObject
3088
                     "decoding to str: need a bytes-like object, %.80s found",
3089
                     Py_TYPE(obj)->tp_name);
gvn
                     
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_FromEncodedObject
3090
        return NULL;
3091
    }
3092
3093
    if (buffer.len == 0) {
gvn
               
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromEncodedObject
3094
        PyBuffer_Release(&buffer);
inline
        
PyBuffer_Release will not be inlined into PyUnicode_FromEncodedObject because its definition is unavailable 
PyUnicode_FromEncodedObject
3095
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_FromEncodedObject
inline
        
PyUnicode_New will not be inlined into PyUnicode_FromEncodedObject 
PyUnicode_FromEncodedObject
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromEncodedObject
gvn
        
load of type %struct._object* eliminated in favor of phi 
PyUnicode_FromEncodedObject
3096
    }
3097
3098
    v = PyUnicode_Decode((char*) buffer.buf, buffer.len, encoding, errors);
inline
        
PyUnicode_Decode too costly to inline (cost=630, threshold=625) 
PyUnicode_FromEncodedObject
inline
        
PyUnicode_Decode will not be inlined into PyUnicode_FromEncodedObject 
PyUnicode_FromEncodedObject
gvn
                                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromEncodedObject
3099
    PyBuffer_Release(&buffer);
inline
    
PyBuffer_Release will not be inlined into PyUnicode_FromEncodedObject because its definition is unavailable 
PyUnicode_FromEncodedObject
3100
    return v;
3101
}
3102
3103
/* Normalize an encoding name: similar to encodings.normalize_encoding(), but
3104
   also convert to lowercase. Return 1 on success, or 0 on error (encoding is
3105
   longer than lower_len-1). */
3106
int
3107
_Py_normalize_encoding(const char *encoding,
3108
                       char *lower,
3109
                       size_t lower_len)
3110
{
3111
    const char *e;
3112
    char *l;
3113
    char *l_end;
3114
    int punct;
3115
3116
    assert(encoding != NULL);
3117
3118
    e = encoding;
3119
    l = lower;
3120
    l_end = &lower[lower_len - 1];
3121
    punct = 0;
3122
    while (1) {
3123
        char c = *e;
gvn
                 
load of type i8 not eliminated because it is clobbered by store 
_Py_normalize_encoding
gvn
                 
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_Decode
gvn
                 
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsEncodedString
3124
        if (c == 0) {
3125
            break;
3126
        }
3127
3128
        if (Py_ISALNUM(c) || c == '.') {
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_Decode
loop-vectorize
            
loop not vectorized 
PyUnicode_Decode
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
_Py_normalize_encoding
loop-vectorize
            
loop not vectorized 
_Py_normalize_encoding
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_AsEncodedString
loop-vectorize
            
loop not vectorized 
PyUnicode_AsEncodedString
3129
            if (punct && l != lower) {
3130
                if (l == l_end) {
3131
                    return 0;
3132
                }
3133
                *l++ = '_';
3134
            }
3135
            punct = 0;
3136
3137
            if (l == l_end) {
3138
                return 0;
3139
            }
3140
            *l++ = Py_TOLOWER(c);
3141
        }
3142
        else {
3143
            punct = 1;
3144
        }
3145
3146
        e++;
3147
    }
3148
    *l = '\0';
3149
    return 1;
3150
}
3151
3152
PyObject *
3153
PyUnicode_Decode(const char *s,
3154
                 Py_ssize_t size,
3155
                 const char *encoding,
3156
                 const char *errors)
3157
{
3158
    PyObject *buffer = NULL, *unicode;
3159
    Py_buffer info;
3160
    char buflower[11];   /* strlen("iso-8859-1\0") == 11, longest shortcut */
3161
3162
    if (encoding == NULL) {
3163
        return PyUnicode_DecodeUTF8Stateful(s, size, errors, NULL);
inline
               
PyUnicode_DecodeUTF8Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_Decode
inline
               
PyUnicode_DecodeUTF8Stateful will not be inlined into PyUnicode_Decode 
PyUnicode_Decode
3164
    }
3165
3166
    /* Shortcuts for common default encodings */
3167
    if (_Py_normalize_encoding(encoding, buflower, sizeof(buflower))) {
inline
        
_Py_normalize_encoding can be inlined into PyUnicode_Decode with cost=90 (threshold=250) 
PyUnicode_Decode
inline
        
_Py_normalize_encoding inlined into PyUnicode_Decode 
PyUnicode_Decode
3168
        char *lower = buflower;
3169
3170
        /* Fast paths */
3171
        if (lower[0] == 'u' && lower[1] == 't' && lower[2] == 'f') {
gvn
            
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_Decode
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_Decode
gvn
                                                  
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_Decode
3172
            lower += 3;
3173
            if (*lower == '_') {
gvn
                
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_Decode
3174
                /* Match "utf8" and "utf_8" */
3175
                lower++;
3176
            }
3177
3178
            if (lower[0] == '8' && lower[1] == 0) {
3179
                return PyUnicode_DecodeUTF8Stateful(s, size, errors, NULL);
inline
                       
PyUnicode_DecodeUTF8Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_Decode
inline
                       
PyUnicode_DecodeUTF8Stateful will not be inlined into PyUnicode_Decode 
PyUnicode_Decode
3180
            }
3181
            else if (lower[0] == '1' && lower[1] == '6' && lower[2] == 0) {
3182
                return PyUnicode_DecodeUTF16(s, size, errors, 0);
inline
                       
PyUnicode_DecodeUTF16 can be inlined into PyUnicode_Decode with cost=5 (threshold=375) 
PyUnicode_Decode
inline
                       
PyUnicode_DecodeUTF16 inlined into PyUnicode_Decode 
PyUnicode_Decode
3183
            }
3184
            else if (lower[0] == '3' && lower[1] == '2' && lower[2] == 0) {
gvn
                     
load of type i8 eliminated in favor of load 
PyUnicode_Decode
3185
                return PyUnicode_DecodeUTF32(s, size, errors, 0);
inline
                       
PyUnicode_DecodeUTF32 can be inlined into PyUnicode_Decode with cost=5 (threshold=375) 
PyUnicode_Decode
inline
                       
PyUnicode_DecodeUTF32 inlined into PyUnicode_Decode 
PyUnicode_Decode
3186
            }
3187
        }
3188
        else {
3189
            if (strcmp(lower, "ascii") == 0
inline
                
strcmp will not be inlined into PyUnicode_Decode because its definition is unavailable 
PyUnicode_Decode
3190
                || strcmp(lower, "us_ascii") == 0) {
inline
                   
strcmp will not be inlined into PyUnicode_Decode because its definition is unavailable 
PyUnicode_Decode
3191
                return PyUnicode_DecodeASCII(s, size, errors);
inline
                       
PyUnicode_DecodeASCII too costly to inline (cost=630, threshold=625) 
PyUnicode_Decode
inline
                       
PyUnicode_DecodeASCII will not be inlined into PyUnicode_Decode 
PyUnicode_Decode
3192
            }
3193
    #ifdef MS_WINDOWS
3194
            else if (strcmp(lower, "mbcs") == 0) {
3195
                return PyUnicode_DecodeMBCS(s, size, errors);
3196
            }
3197
    #endif
3198
            else if (strcmp(lower, "latin1") == 0
inline
                     
strcmp will not be inlined into PyUnicode_Decode because its definition is unavailable 
PyUnicode_Decode
3199
                     || strcmp(lower, "latin_1") == 0
inline
                        
strcmp will not be inlined into PyUnicode_Decode because its definition is unavailable 
PyUnicode_Decode
3200
                     || strcmp(lower, "iso_8859_1") == 0
inline
                        
strcmp will not be inlined into PyUnicode_Decode because its definition is unavailable 
PyUnicode_Decode
3201
                     || strcmp(lower, "iso8859_1") == 0) {
inline
                        
strcmp will not be inlined into PyUnicode_Decode because its definition is unavailable 
PyUnicode_Decode
3202
                return PyUnicode_DecodeLatin1(s, size, errors);
inline
                       
PyUnicode_DecodeLatin1 can be inlined into PyUnicode_Decode with cost=-5 (threshold=375) 
PyUnicode_Decode
inline
                       
PyUnicode_DecodeLatin1 inlined into PyUnicode_Decode 
PyUnicode_Decode
3203
            }
3204
        }
3205
    }
3206
3207
    /* Decode via the codec registry */
3208
    buffer = NULL;
3209
    if (PyBuffer_FillInfo(&info, NULL, (void *)s, size, 1, PyBUF_FULL_RO) < 0)
inline
        
PyBuffer_FillInfo will not be inlined into PyUnicode_Decode because its definition is unavailable 
PyUnicode_Decode
3210
        goto onError;
3211
    buffer = PyMemoryView_FromBuffer(&info);
inline
             
PyMemoryView_FromBuffer will not be inlined into PyUnicode_Decode because its definition is unavailable 
PyUnicode_Decode
3212
    if (buffer == NULL)
3213
        goto onError;
3214
    unicode = _PyCodec_DecodeText(buffer, encoding, errors);
inline
              
_PyCodec_DecodeText will not be inlined into PyUnicode_Decode because its definition is unavailable 
PyUnicode_Decode
3215
    if (unicode == NULL)
3216
        goto onError;
3217
    if (!PyUnicode_Check(unicode)) {
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Decode
3218
        PyErr_Format(PyExc_TypeError,
inline
        
PyErr_Format will not be inlined into PyUnicode_Decode because its definition is unavailable 
PyUnicode_Decode
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Decode
3219
                     "'%.400s' decoder returned '%.400s' instead of 'str'; "
3220
                     "use codecs.decode() to decode to arbitrary types",
3221
                     encoding,
3222
                     Py_TYPE(unicode)->tp_name);
3223
        Py_DECREF(unicode);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Decode
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Decode
3224
        goto onError;
3225
    }
3226
    Py_DECREF(buffer);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Decode
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Decode
3227
    return unicode_result(unicode);
inline
           
unicode_result too costly to inline (cost=460, threshold=250) 
PyUnicode_Decode
inline
           
unicode_result will not be inlined into PyUnicode_Decode 
PyUnicode_Decode
3228
3229
  onError:
3230
    Py_XDECREF(buffer);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Decode
gvn
    
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Decode
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Decode
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Decode
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Decode
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Decode
3231
    return NULL;
3232
}
3233
3234
PyObject *
3235
PyUnicode_AsDecodedObject(PyObject *unicode,
3236
                          const char *encoding,
3237
                          const char *errors)
3238
{
3239
    if (!PyUnicode_Check(unicode)) {
3240
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_AsDecodedObject because its definition is unavailable 
PyUnicode_AsDecodedObject
3241
        return NULL;
3242
    }
3243
3244
    if (PyErr_WarnEx(PyExc_DeprecationWarning,
inline
        
PyErr_WarnEx will not be inlined into PyUnicode_AsDecodedObject because its definition is unavailable 
PyUnicode_AsDecodedObject
3245
                     "PyUnicode_AsDecodedObject() is deprecated; "
3246
                     "use PyCodec_Decode() to decode from str", 1) < 0)
3247
        return NULL;
3248
3249
    if (encoding == NULL)
3250
        encoding = PyUnicode_GetDefaultEncoding();
3251
3252
    /* Decode via the codec registry */
3253
    return PyCodec_Decode(unicode, encoding, errors);
inline
           
PyCodec_Decode will not be inlined into PyUnicode_AsDecodedObject because its definition is unavailable 
PyUnicode_AsDecodedObject
3254
}
3255
3256
PyObject *
3257
PyUnicode_AsDecodedUnicode(PyObject *unicode,
3258
                           const char *encoding,
3259
                           const char *errors)
3260
{
3261
    PyObject *v;
3262
3263
    if (!PyUnicode_Check(unicode)) {
3264
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_AsDecodedUnicode because its definition is unavailable 
PyUnicode_AsDecodedUnicode
3265
        goto onError;
3266
    }
3267
3268
    if (PyErr_WarnEx(PyExc_DeprecationWarning,
inline
        
PyErr_WarnEx will not be inlined into PyUnicode_AsDecodedUnicode because its definition is unavailable 
PyUnicode_AsDecodedUnicode
3269
                     "PyUnicode_AsDecodedUnicode() is deprecated; "
3270
                     "use PyCodec_Decode() to decode from str to str", 1) < 0)
3271
        return NULL;
3272
3273
    if (encoding == NULL)
3274
        encoding = PyUnicode_GetDefaultEncoding();
3275
3276
    /* Decode via the codec registry */
3277
    v = PyCodec_Decode(unicode, encoding, errors);
inline
        
PyCodec_Decode will not be inlined into PyUnicode_AsDecodedUnicode because its definition is unavailable 
PyUnicode_AsDecodedUnicode
3278
    if (v == NULL)
3279
        goto onError;
3280
    if (!PyUnicode_Check(v)) {
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_AsDecodedUnicode
3281
        PyErr_Format(PyExc_TypeError,
inline
        
PyErr_Format will not be inlined into PyUnicode_AsDecodedUnicode because its definition is unavailable 
PyUnicode_AsDecodedUnicode
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_AsDecodedUnicode
3282
                     "'%.400s' decoder returned '%.400s' instead of 'str'; "
3283
                     "use codecs.decode() to decode to arbitrary types",
3284
                     encoding,
3285
                     Py_TYPE(unicode)->tp_name);
gvn
                     
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsDecodedUnicode
3286
        Py_DECREF(v);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsDecodedUnicode
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsDecodedUnicode
3287
        goto onError;
3288
    }
3289
    return unicode_result(v);
inline
           
unicode_result too costly to inline (cost=460, threshold=250) 
PyUnicode_AsDecodedUnicode
inline
           
unicode_result will not be inlined into PyUnicode_AsDecodedUnicode 
PyUnicode_AsDecodedUnicode
3290
3291
  onError:
3292
    return NULL;
3293
}
3294
3295
PyObject *
3296
PyUnicode_Encode(const Py_UNICODE *s,
3297
                 Py_ssize_t size,
3298
                 const char *encoding,
3299
                 const char *errors)
3300
{
3301
    PyObject *v, *unicode;
3302
3303
    unicode = PyUnicode_FromUnicode(s, size);
inline
              
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_Encode
inline
              
PyUnicode_FromUnicode will not be inlined into PyUnicode_Encode 
PyUnicode_Encode
3304
    if (unicode == NULL)
3305
        return NULL;
3306
    v = PyUnicode_AsEncodedString(unicode, encoding, errors);
inline
        
PyUnicode_AsEncodedString too costly to inline (cost=655, threshold=625) 
PyUnicode_Encode
inline
        
PyUnicode_AsEncodedString will not be inlined into PyUnicode_Encode 
PyUnicode_Encode
3307
    Py_DECREF(unicode);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Encode
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Encode
3308
    return v;
3309
}
3310
3311
PyObject *
3312
PyUnicode_AsEncodedObject(PyObject *unicode,
3313
                          const char *encoding,
3314
                          const char *errors)
3315
{
3316
    PyObject *v;
3317
3318
    if (!PyUnicode_Check(unicode)) {
3319
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_AsEncodedObject because its definition is unavailable 
PyUnicode_AsEncodedObject
3320
        goto onError;
3321
    }
3322
3323
    if (PyErr_WarnEx(PyExc_DeprecationWarning,
inline
        
PyErr_WarnEx will not be inlined into PyUnicode_AsEncodedObject because its definition is unavailable 
PyUnicode_AsEncodedObject
3324
                     "PyUnicode_AsEncodedObject() is deprecated; "
3325
                     "use PyUnicode_AsEncodedString() to encode from str to bytes "
3326
                     "or PyCodec_Encode() for generic encoding", 1) < 0)
3327
        return NULL;
3328
3329
    if (encoding == NULL)
3330
        encoding = PyUnicode_GetDefaultEncoding();
3331
3332
    /* Encode via the codec registry */
3333
    v = PyCodec_Encode(unicode, encoding, errors);
inline
        
PyCodec_Encode will not be inlined into PyUnicode_AsEncodedObject because its definition is unavailable 
PyUnicode_AsEncodedObject
3334
    if (v == NULL)
3335
        goto onError;
3336
    return v;
3337
3338
  onError:
3339
    return NULL;
3340
}
3341
3342
static size_t
3343
wcstombs_errorpos(const wchar_t *wstr)
3344
{
3345
    size_t len;
3346
#if SIZEOF_WCHAR_T == 2
3347
    wchar_t buf[3];
3348
#else
3349
    wchar_t buf[2];
3350
#endif
3351
    char outbuf[MB_LEN_MAX];
3352
    const wchar_t *start, *previous;
3353
3354
#if SIZEOF_WCHAR_T == 2
3355
    buf[2] = 0;
3356
#else
3357
    buf[1] = 0;
3358
#endif
3359
    start = wstr;
3360
    while (*wstr != L'\0')
gvn
           
load of type i32 not eliminated because it is clobbered by call 
wcstombs_errorpos
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
gvn
           
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_EncodeLocale
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_EncodeLocale
loop-vectorize
    
loop not vectorized 
PyUnicode_EncodeLocale
3361
    {
3362
        previous = wstr;
3363
#if SIZEOF_WCHAR_T == 2
3364
        if (Py_UNICODE_IS_HIGH_SURROGATE(wstr[0])
3365
            && Py_UNICODE_IS_LOW_SURROGATE(wstr[1]))
3366
        {
3367
            buf[0] = wstr[0];
3368
            buf[1] = wstr[1];
3369
            wstr += 2;
3370
        }
3371
        else {
3372
            buf[0] = *wstr;
3373
            buf[1] = 0;
3374
            wstr++;
3375
        }
3376
#else
3377
        buf[0] = *wstr;
licm
        
hosting getelementptr 
wcstombs_errorpos
3378
        wstr++;
3379
#endif
3380
        len = wcstombs(outbuf, buf, sizeof(outbuf));
inline
              
wcstombs will not be inlined into wcstombs_errorpos because its definition is unavailable 
wcstombs_errorpos
3381
        if (len == (size_t)-1)
3382
            return previous - start;
3383
    }
3384
3385
    /* failed to find the unencodable character */
3386
    return 0;
3387
}
3388
3389
static int
3390
locale_error_handler(const char *errors, int *surrogateescape)
3391
{
3392
    _Py_error_handler error_handler = get_error_handler(errors);
inline
                                      
get_error_handler too costly to inline (cost=325, threshold=250) 
locale_error_handler
inline
                                      
get_error_handler will not be inlined into locale_error_handler 
locale_error_handler
inline
                                      
get_error_handler too costly to inline (cost=325, threshold=250) 
PyUnicode_EncodeLocale
inline
                                      
get_error_handler will not be inlined into PyUnicode_EncodeLocale 
PyUnicode_EncodeLocale
inline
                                      
get_error_handler too costly to inline (cost=325, threshold=250) 
PyUnicode_DecodeLocaleAndSize
inline
                                      
get_error_handler will not be inlined into PyUnicode_DecodeLocaleAndSize 
PyUnicode_DecodeLocaleAndSize
3393
    switch (error_handler)
3394
    {
3395
    case _Py_ERROR_STRICT:
3396
        *surrogateescape = 0;
3397
        return 0;
3398
    case _Py_ERROR_SURROGATEESCAPE:
3399
        *surrogateescape = 1;
3400
        return 0;
3401
    default:
3402
        PyErr_Format(PyExc_ValueError,
inline
        
PyErr_Format will not be inlined into locale_error_handler because its definition is unavailable 
locale_error_handler
3403
                     "only 'strict' and 'surrogateescape' error handlers "
3404
                     "are supported, not '%s'",
3405
                     errors);
3406
        return -1;
3407
    }
3408
}
3409
3410
PyObject *
3411
PyUnicode_EncodeLocale(PyObject *unicode, const char *errors)
3412
{
3413
    Py_ssize_t wlen, wlen2;
3414
    wchar_t *wstr;
3415
    PyObject *bytes = NULL;
3416
    char *errmsg;
3417
    PyObject *reason = NULL;
3418
    PyObject *exc;
3419
    size_t error_pos;
3420
    int surrogateescape;
3421
3422
    if (locale_error_handler(errors, &surrogateescape) < 0)
inline
        
locale_error_handler can be inlined into PyUnicode_EncodeLocale with cost=60 (threshold=250) 
PyUnicode_EncodeLocale
inline
        
locale_error_handler inlined into PyUnicode_EncodeLocale 
PyUnicode_EncodeLocale
3423
        return NULL;
3424
3425
    wstr = PyUnicode_AsWideCharString(unicode, &wlen);
inline
           
PyUnicode_AsWideCharString too costly to inline (cost=315, threshold=250) 
PyUnicode_EncodeLocale
inline
           
PyUnicode_AsWideCharString will not be inlined into PyUnicode_EncodeLocale 
PyUnicode_EncodeLocale
3426
    if (wstr == NULL)
3427
        return NULL;
3428
3429
    wlen2 = wcslen(wstr);
inline
            
wcslen will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3430
    if (wlen2 != wlen) {
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
3431
        PyMem_Free(wstr);
inline
        
PyMem_Free will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3432
        PyErr_SetString(PyExc_ValueError, "embedded null character");
inline
        
PyErr_SetString will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
3433
        return NULL;
3434
    }
3435
3436
    if (surrogateescape) {
3437
        /* "surrogateescape" error handler */
3438
        char *str;
3439
3440
        str = Py_EncodeLocale(wstr, &error_pos);
inline
              
Py_EncodeLocale will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3441
        if (str == NULL) {
3442
            if (error_pos == (size_t)-1) {
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
3443
                PyErr_NoMemory();
inline
                
PyErr_NoMemory will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3444
                PyMem_Free(wstr);
inline
                
PyMem_Free will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3445
                return NULL;
3446
            }
3447
            else {
3448
                goto encode_error;
3449
            }
3450
        }
3451
        PyMem_Free(wstr);
inline
        
PyMem_Free will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3452
3453
        bytes = PyBytes_FromString(str);
inline
                
PyBytes_FromString will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3454
        PyMem_Free(str);
inline
        
PyMem_Free will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3455
    }
3456
    else {
3457
        /* strict mode */
3458
        size_t len, len2;
3459
3460
        len = wcstombs(NULL, wstr, 0);
inline
              
wcstombs will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3461
        if (len == (size_t)-1) {
3462
            error_pos = (size_t)-1;
3463
            goto encode_error;
3464
        }
3465
3466
        bytes = PyBytes_FromStringAndSize(NULL, len);
inline
                
PyBytes_FromStringAndSize will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3467
        if (bytes == NULL) {
3468
            PyMem_Free(wstr);
inline
            
PyMem_Free will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3469
            return NULL;
3470
        }
3471
3472
        len2 = wcstombs(PyBytes_AS_STRING(bytes), wstr, len+1);
inline
               
wcstombs will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3473
        if (len2 == (size_t)-1 || len2 > len) {
3474
            error_pos = (size_t)-1;
3475
            goto encode_error;
3476
        }
3477
        PyMem_Free(wstr);
inline
        
PyMem_Free will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3478
    }
3479
    return bytes;
3480
3481
encode_error:
3482
    errmsg = strerror(errno);
inline
                      
__errno_location will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
inline
             
strerror will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3483
    assert(errmsg != NULL);
3484
3485
    if (error_pos == (size_t)-1)
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
3486
        error_pos = wcstombs_errorpos(wstr);
inline
                    
wcstombs_errorpos can be inlined into PyUnicode_EncodeLocale with cost=-14935 (threshold=250) 
PyUnicode_EncodeLocale
inline
                    
wcstombs_errorpos inlined into PyUnicode_EncodeLocale 
PyUnicode_EncodeLocale
3487
3488
    PyMem_Free(wstr);
inline
    
PyMem_Free will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3489
    Py_XDECREF(bytes);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
3490
3491
    if (errmsg != NULL) {
3492
        size_t errlen;
3493
        wstr = Py_DecodeLocale(errmsg, &errlen);
inline
               
Py_DecodeLocale will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3494
        if (wstr != NULL) {
3495
            reason = PyUnicode_FromWideChar(wstr, errlen);
inline
                     
PyUnicode_FromWideChar can be inlined into PyUnicode_EncodeLocale with cost=45 (threshold=250) 
PyUnicode_EncodeLocale
inline
                     
PyUnicode_FromWideChar inlined into PyUnicode_EncodeLocale 
PyUnicode_EncodeLocale
gvn
                                                  
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
3496
            PyMem_RawFree(wstr);
inline
            
PyMem_RawFree will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3497
        } else
3498
            errmsg = NULL;
3499
    }
3500
    if (errmsg == NULL)
3501
        reason = PyUnicode_FromString(
inline
                 
PyUnicode_FromString can be inlined into PyUnicode_EncodeLocale with cost=105 (threshold=250) 
PyUnicode_EncodeLocale
inline
                 
PyUnicode_FromString inlined into PyUnicode_EncodeLocale 
PyUnicode_EncodeLocale
3502
            "wcstombs() encountered an unencodable "
3503
            "wide character");
3504
    if (reason == NULL)
3505
        return NULL;
3506
3507
    exc = PyObject_CallFunction(PyExc_UnicodeEncodeError, "sOnnO",
inline
          
_PyObject_CallFunction_SizeT will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
3508
                                "locale", unicode,
3509
                                (Py_ssize_t)error_pos,
gvn
                                            
load of type i64 not eliminated in favor of load because it is clobbered by call 
PyUnicode_EncodeLocale
gvn
                                            
load of type i64 not eliminated in favor of load because it is clobbered by call 
PyUnicode_EncodeLocale
3510
                                (Py_ssize_t)(error_pos+1),
3511
                                reason);
3512
    Py_DECREF(reason);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
3513
    if (exc != NULL) {
3514
        PyCodec_StrictErrors(exc);
inline
        
PyCodec_StrictErrors will not be inlined into PyUnicode_EncodeLocale because its definition is unavailable 
PyUnicode_EncodeLocale
3515
        Py_XDECREF(exc);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeLocale
3516
    }
3517
    return NULL;
3518
}
3519
3520
PyObject *
3521
PyUnicode_EncodeFSDefault(PyObject *unicode)
3522
{
3523
#if defined(__APPLE__)
3524
    return _PyUnicode_AsUTF8String(unicode, Py_FileSystemDefaultEncodeErrors);
3525
#else
3526
    PyInterpreterState *interp = PyThreadState_GET()->interp;
3527
    /* Bootstrap check: if the filesystem codec is implemented in Python, we
3528
       cannot use it to encode and decode filenames before it is loaded. Load
3529
       the Python codec requires to encode at least its own filename. Use the C
3530
       version of the locale codec until the codec registry is initialized and
3531
       the Python codec is loaded.
3532
3533
       Py_FileSystemDefaultEncoding is shared between all interpreters, we
3534
       cannot only rely on it: check also interp->fscodec_initialized for
3535
       subinterpreters. */
3536
    if (Py_FileSystemDefaultEncoding && interp->fscodec_initialized) {
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FSConverter
3537
        return PyUnicode_AsEncodedString(unicode,
inline
               
PyUnicode_AsEncodedString too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeFSDefault
inline
               
PyUnicode_AsEncodedString will not be inlined into PyUnicode_EncodeFSDefault 
PyUnicode_EncodeFSDefault
inline
               
PyUnicode_AsEncodedString too costly to inline (cost=630, threshold=625) 
PyUnicode_FSConverter
inline
               
PyUnicode_AsEncodedString will not be inlined into PyUnicode_FSConverter 
PyUnicode_FSConverter
3538
                                         Py_FileSystemDefaultEncoding,
3539
                                         Py_FileSystemDefaultEncodeErrors);
gvn
                                         
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FSConverter
3540
    }
3541
    else {
3542
        return PyUnicode_EncodeLocale(unicode, Py_FileSystemDefaultEncodeErrors);
inline
               
PyUnicode_EncodeLocale too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeFSDefault
inline
               
PyUnicode_EncodeLocale will not be inlined into PyUnicode_EncodeFSDefault 
PyUnicode_EncodeFSDefault
inline
               
PyUnicode_EncodeLocale too costly to inline (cost=630, threshold=625) 
PyUnicode_FSConverter
inline
               
PyUnicode_EncodeLocale will not be inlined into PyUnicode_FSConverter 
PyUnicode_FSConverter
3543
    }
3544
#endif
3545
}
3546
3547
PyObject *
3548
PyUnicode_AsEncodedString(PyObject *unicode,
3549
                          const char *encoding,
3550
                          const char *errors)
3551
{
3552
    PyObject *v;
3553
    char buflower[11];   /* strlen("iso_8859_1\0") == 11, longest shortcut */
3554
3555
    if (!PyUnicode_Check(unicode)) {
3556
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_AsEncodedString because its definition is unavailable 
PyUnicode_AsEncodedString
3557
        return NULL;
3558
    }
3559
3560
    if (encoding == NULL) {
3561
        return _PyUnicode_AsUTF8String(unicode, errors);
inline
               
_PyUnicode_AsUTF8String too costly to inline (cost=635, threshold=625) 
PyUnicode_AsEncodedString
inline
               
_PyUnicode_AsUTF8String will not be inlined into PyUnicode_AsEncodedString 
PyUnicode_AsEncodedString
3562
    }
3563
3564
    /* Shortcuts for common default encodings */
3565
    if (_Py_normalize_encoding(encoding, buflower, sizeof(buflower))) {
inline
        
_Py_normalize_encoding can be inlined into PyUnicode_AsEncodedString with cost=90 (threshold=250) 
PyUnicode_AsEncodedString
inline
        
_Py_normalize_encoding inlined into PyUnicode_AsEncodedString 
PyUnicode_AsEncodedString
3566
        char *lower = buflower;
3567
3568
        /* Fast paths */
3569
        if (lower[0] == 'u' && lower[1] == 't' && lower[2] == 'f') {
gvn
            
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsEncodedString
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsEncodedString
gvn
                                                  
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsEncodedString
3570
            lower += 3;
3571
            if (*lower == '_') {
gvn
                
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsEncodedString
3572
                /* Match "utf8" and "utf_8" */
3573
                lower++;
3574
            }
3575
3576
            if (lower[0] == '8' && lower[1] == 0) {
3577
                return _PyUnicode_AsUTF8String(unicode, errors);
inline
                       
_PyUnicode_AsUTF8String too costly to inline (cost=635, threshold=625) 
PyUnicode_AsEncodedString
inline
                       
_PyUnicode_AsUTF8String will not be inlined into PyUnicode_AsEncodedString 
PyUnicode_AsEncodedString
3578
            }
3579
            else if (lower[0] == '1' && lower[1] == '6' && lower[2] == 0) {
3580
                return _PyUnicode_EncodeUTF16(unicode, errors, 0);
inline
                       
_PyUnicode_EncodeUTF16 too costly to inline (cost=630, threshold=625) 
PyUnicode_AsEncodedString
inline
                       
_PyUnicode_EncodeUTF16 will not be inlined into PyUnicode_AsEncodedString 
PyUnicode_AsEncodedString
3581
            }
3582
            else if (lower[0] == '3' && lower[1] == '2' && lower[2] == 0) {
gvn
                     
load of type i8 eliminated in favor of load 
PyUnicode_AsEncodedString
3583
                return _PyUnicode_EncodeUTF32(unicode, errors, 0);
inline
                       
_PyUnicode_EncodeUTF32 too costly to inline (cost=630, threshold=625) 
PyUnicode_AsEncodedString
inline
                       
_PyUnicode_EncodeUTF32 will not be inlined into PyUnicode_AsEncodedString 
PyUnicode_AsEncodedString
3584
            }
3585
        }
3586
        else {
3587
            if (strcmp(lower, "ascii") == 0
inline
                
strcmp will not be inlined into PyUnicode_AsEncodedString because its definition is unavailable 
PyUnicode_AsEncodedString
3588
                || strcmp(lower, "us_ascii") == 0) {
inline
                   
strcmp will not be inlined into PyUnicode_AsEncodedString because its definition is unavailable 
PyUnicode_AsEncodedString
3589
                return _PyUnicode_AsASCIIString(unicode, errors);
inline
                       
_PyUnicode_AsASCIIString can be inlined into PyUnicode_AsEncodedString with cost=205 (threshold=250) 
PyUnicode_AsEncodedString
inline
                       
_PyUnicode_AsASCIIString inlined into PyUnicode_AsEncodedString 
PyUnicode_AsEncodedString
3590
            }
3591
#ifdef MS_WINDOWS
3592
            else if (strcmp(lower, "mbcs") == 0) {
3593
                return PyUnicode_EncodeCodePage(CP_ACP, unicode, errors);
3594
            }
3595
#endif
3596
            else if (strcmp(lower, "latin1") == 0 ||
inline
                     
strcmp will not be inlined into PyUnicode_AsEncodedString because its definition is unavailable 
PyUnicode_AsEncodedString
3597
                     strcmp(lower, "latin_1") == 0 ||
inline
                     
strcmp will not be inlined into PyUnicode_AsEncodedString because its definition is unavailable 
PyUnicode_AsEncodedString
3598
                     strcmp(lower, "iso_8859_1") == 0 ||
inline
                     
strcmp will not be inlined into PyUnicode_AsEncodedString because its definition is unavailable 
PyUnicode_AsEncodedString
3599
                     strcmp(lower, "iso8859_1") == 0) {
inline
                     
strcmp will not be inlined into PyUnicode_AsEncodedString because its definition is unavailable 
PyUnicode_AsEncodedString
3600
                return _PyUnicode_AsLatin1String(unicode, errors);
inline
                       
_PyUnicode_AsLatin1String can be inlined into PyUnicode_AsEncodedString with cost=220 (threshold=250) 
PyUnicode_AsEncodedString
inline
                       
_PyUnicode_AsLatin1String inlined into PyUnicode_AsEncodedString 
PyUnicode_AsEncodedString
3601
            }
3602
        }
3603
    }
3604
3605
    /* Encode via the codec registry */
3606
    v = _PyCodec_EncodeText(unicode, encoding, errors);
inline
        
_PyCodec_EncodeText will not be inlined into PyUnicode_AsEncodedString because its definition is unavailable 
PyUnicode_AsEncodedString
3607
    if (v == NULL)
3608
        return NULL;
3609
3610
    /* The normal path */
3611
    if (PyBytes_Check(v))
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
3612
        return v;
3613
3614
    /* If the codec returns a buffer, raise a warning and convert to bytes */
3615
    if (PyByteArray_Check(v)) {
inline
        
PyType_IsSubtype will not be inlined into PyUnicode_AsEncodedString because its definition is unavailable 
PyUnicode_AsEncodedString
3616
        int error;
3617
        PyObject *b;
3618
3619
        error = PyErr_WarnFormat(PyExc_RuntimeWarning, 1,
inline
                
PyErr_WarnFormat will not be inlined into PyUnicode_AsEncodedString because its definition is unavailable 
PyUnicode_AsEncodedString
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
gvn
                                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
3620
            "encoder %s returned bytearray instead of bytes; "
3621
            "use codecs.encode() to encode to arbitrary types",
3622
            encoding);
3623
        if (error) {
3624
            Py_DECREF(v);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsEncodedString
3625
            return NULL;
3626
        }
3627
3628
        b = PyBytes_FromStringAndSize(PyByteArray_AS_STRING(v), Py_SIZE(v));
inline
            
PyBytes_FromStringAndSize will not be inlined into PyUnicode_AsEncodedString because its definition is unavailable 
PyUnicode_AsEncodedString
gvn
                                      
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
gvn
                                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
3629
        Py_DECREF(v);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsEncodedString
3630
        return b;
3631
    }
3632
3633
    PyErr_Format(PyExc_TypeError,
inline
    
PyErr_Format will not be inlined into PyUnicode_AsEncodedString because its definition is unavailable 
PyUnicode_AsEncodedString
gvn
                 
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
3634
                 "'%.400s' encoder returned '%.400s' instead of 'bytes'; "
3635
                 "use codecs.encode() to encode to arbitrary types",
3636
                 encoding,
3637
                 Py_TYPE(v)->tp_name);
gvn
                 
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsEncodedString
3638
    Py_DECREF(v);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
3639
    return NULL;
3640
}
3641
3642
PyObject *
3643
PyUnicode_AsEncodedUnicode(PyObject *unicode,
3644
                           const char *encoding,
3645
                           const char *errors)
3646
{
3647
    PyObject *v;
3648
3649
    if (!PyUnicode_Check(unicode)) {
3650
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_AsEncodedUnicode because its definition is unavailable 
PyUnicode_AsEncodedUnicode
3651
        goto onError;
3652
    }
3653
3654
    if (PyErr_WarnEx(PyExc_DeprecationWarning,
inline
        
PyErr_WarnEx will not be inlined into PyUnicode_AsEncodedUnicode because its definition is unavailable 
PyUnicode_AsEncodedUnicode
3655
                     "PyUnicode_AsEncodedUnicode() is deprecated; "
3656
                     "use PyCodec_Encode() to encode from str to str", 1) < 0)
3657
        return NULL;
3658
3659
    if (encoding == NULL)
3660
        encoding = PyUnicode_GetDefaultEncoding();
3661
3662
    /* Encode via the codec registry */
3663
    v = PyCodec_Encode(unicode, encoding, errors);
inline
        
PyCodec_Encode will not be inlined into PyUnicode_AsEncodedUnicode because its definition is unavailable 
PyUnicode_AsEncodedUnicode
3664
    if (v == NULL)
3665
        goto onError;
3666
    if (!PyUnicode_Check(v)) {
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_AsEncodedUnicode
3667
        PyErr_Format(PyExc_TypeError,
inline
        
PyErr_Format will not be inlined into PyUnicode_AsEncodedUnicode because its definition is unavailable 
PyUnicode_AsEncodedUnicode
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_AsEncodedUnicode
3668
                     "'%.400s' encoder returned '%.400s' instead of 'str'; "
3669
                     "use codecs.encode() to encode to arbitrary types",
3670
                     encoding,
3671
                     Py_TYPE(v)->tp_name);
3672
        Py_DECREF(v);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsEncodedUnicode
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsEncodedUnicode
3673
        goto onError;
3674
    }
3675
    return v;
3676
3677
  onError:
3678
    return NULL;
3679
}
3680
3681
static size_t
3682
mbstowcs_errorpos(const char *str, size_t len)
3683
{
3684
#ifdef HAVE_MBRTOWC
3685
    const char *start = str;
3686
    mbstate_t mbs;
3687
    size_t converted;
3688
    wchar_t ch;
3689
3690
    memset(&mbs, 0, sizeof mbs);
3691
    while (len)
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeLocaleAndSize
loop-vectorize
    
loop not vectorized 
PyUnicode_DecodeLocaleAndSize
3692
    {
3693
        converted = mbrtowc(&ch, str, len, &mbs);
inline
                    
mbrtowc will not be inlined into mbstowcs_errorpos because its definition is unavailable 
mbstowcs_errorpos
3694
        if (converted == 0)
3695
            /* Reached end of string */
3696
            break;
3697
        if (converted == (size_t)-1 || converted == (size_t)-2) {
3698
            /* Conversion error or incomplete character */
3699
            return str - start;
3700
        }
3701
        else {
3702
            str += converted;
3703
            len -= converted;
3704
        }
3705
    }
3706
    /* failed to find the undecodable byte sequence */
3707
    return 0;
3708
#endif
3709
    return 0;
3710
}
3711
3712
PyObject*
3713
PyUnicode_DecodeLocaleAndSize(const char *str, Py_ssize_t len,
3714
                              const char *errors)
3715
{
3716
    wchar_t smallbuf[256];
3717
    size_t smallbuf_len = Py_ARRAY_LENGTH(smallbuf);
3718
    wchar_t *wstr;
3719
    size_t wlen, wlen2;
3720
    PyObject *unicode;
3721
    int surrogateescape;
3722
    size_t error_pos;
3723
    char *errmsg;
3724
    PyObject *reason = NULL;   /* initialize to prevent gcc warning */
3725
    PyObject *exc;
3726
3727
    if (locale_error_handler(errors, &surrogateescape) < 0)
inline
        
locale_error_handler can be inlined into PyUnicode_DecodeLocaleAndSize with cost=-14940 (threshold=250) 
PyUnicode_DecodeLocaleAndSize
inline
        
locale_error_handler inlined into PyUnicode_DecodeLocaleAndSize 
PyUnicode_DecodeLocaleAndSize
3728
        return NULL;
3729
3730
    if (str[len] != '\0' || (size_t)len != strlen(str))  {
inline
                                           
strlen will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3731
        PyErr_SetString(PyExc_ValueError, "embedded null byte");
inline
        
PyErr_SetString will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3732
        return NULL;
3733
    }
3734
3735
    if (surrogateescape) {
3736
        /* "surrogateescape" error handler */
3737
        wstr = Py_DecodeLocale(str, &wlen);
inline
               
Py_DecodeLocale will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3738
        if (wstr == NULL) {
3739
            if (wlen == (size_t)-1)
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeLocaleAndSize
3740
                PyErr_NoMemory();
inline
                
PyErr_NoMemory will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3741
            else
3742
                PyErr_SetFromErrno(PyExc_OSError);
inline
                
PyErr_SetFromErrno will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
gvn
                                   
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeLocaleAndSize
3743
            return NULL;
3744
        }
3745
3746
        unicode = PyUnicode_FromWideChar(wstr, wlen);
inline
                  
PyUnicode_FromWideChar can be inlined into PyUnicode_DecodeLocaleAndSize with cost=45 (threshold=250) 
PyUnicode_DecodeLocaleAndSize
inline
                  
PyUnicode_FromWideChar inlined into PyUnicode_DecodeLocaleAndSize 
PyUnicode_DecodeLocaleAndSize
3747
        PyMem_RawFree(wstr);
inline
        
PyMem_RawFree will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3748
    }
3749
    else {
3750
        /* strict mode */
3751
#ifndef HAVE_BROKEN_MBSTOWCS
3752
        wlen = mbstowcs(NULL, str, 0);
inline
               
mbstowcs will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3753
#else
3754
        wlen = len;
3755
#endif
3756
        if (wlen == (size_t)-1)
3757
            goto decode_error;
3758
        if (wlen+1 <= smallbuf_len) {
3759
            wstr = smallbuf;
3760
        }
3761
        else {
3762
            wstr = PyMem_New(wchar_t, wlen+1);
inline
                   
PyMem_Malloc will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3763
            if (!wstr)
3764
                return PyErr_NoMemory();
inline
                       
PyErr_NoMemory will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3765
        }
3766
3767
        wlen2 = mbstowcs(wstr, str, wlen+1);
inline
                
mbstowcs will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
gvn
                                    
load of type i64 eliminated in favor of call 
PyUnicode_DecodeLocaleAndSize
3768
        if (wlen2 == (size_t)-1) {
3769
            if (wstr != smallbuf)
3770
                PyMem_Free(wstr);
inline
                
PyMem_Free will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3771
            goto decode_error;
3772
        }
3773
#ifdef HAVE_BROKEN_MBSTOWCS
3774
        assert(wlen2 == wlen);
3775
#endif
3776
        unicode = PyUnicode_FromWideChar(wstr, wlen2);
inline
                  
PyUnicode_FromWideChar can be inlined into PyUnicode_DecodeLocaleAndSize with cost=190 (threshold=250) 
PyUnicode_DecodeLocaleAndSize
inline
                  
PyUnicode_FromWideChar inlined into PyUnicode_DecodeLocaleAndSize 
PyUnicode_DecodeLocaleAndSize
3777
        if (wstr != smallbuf)
3778
            PyMem_Free(wstr);
inline
            
PyMem_Free will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3779
    }
3780
    return unicode;
3781
3782
decode_error:
3783
    reason = NULL;
3784
    errmsg = strerror(errno);
inline
                      
__errno_location will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
inline
             
strerror will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3785
    assert(errmsg != NULL);
3786
3787
    error_pos = mbstowcs_errorpos(str, len);
inline
                
mbstowcs_errorpos can be inlined into PyUnicode_DecodeLocaleAndSize with cost=-14920 (threshold=250) 
PyUnicode_DecodeLocaleAndSize
inline
                
mbstowcs_errorpos inlined into PyUnicode_DecodeLocaleAndSize 
PyUnicode_DecodeLocaleAndSize
3788
    if (errmsg != NULL) {
3789
        size_t errlen;
3790
        wstr = Py_DecodeLocale(errmsg, &errlen);
inline
               
Py_DecodeLocale will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3791
        if (wstr != NULL) {
3792
            reason = PyUnicode_FromWideChar(wstr, errlen);
inline
                     
PyUnicode_FromWideChar can be inlined into PyUnicode_DecodeLocaleAndSize with cost=45 (threshold=250) 
PyUnicode_DecodeLocaleAndSize
inline
                     
PyUnicode_FromWideChar inlined into PyUnicode_DecodeLocaleAndSize 
PyUnicode_DecodeLocaleAndSize
gvn
                                                  
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeLocaleAndSize
3793
            PyMem_RawFree(wstr);
inline
            
PyMem_RawFree will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3794
        }
3795
    }
3796
    if (reason == NULL)
3797
        reason = PyUnicode_FromString(
inline
                 
PyUnicode_FromString can be inlined into PyUnicode_DecodeLocaleAndSize with cost=105 (threshold=250) 
PyUnicode_DecodeLocaleAndSize
inline
                 
PyUnicode_FromString inlined into PyUnicode_DecodeLocaleAndSize 
PyUnicode_DecodeLocaleAndSize
3798
            "mbstowcs() encountered an invalid multibyte sequence");
3799
    if (reason == NULL)
3800
        return NULL;
3801
3802
    exc = PyObject_CallFunction(PyExc_UnicodeDecodeError, "sy#nnO",
inline
          
_PyObject_CallFunction_SizeT will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeLocaleAndSize
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeLocaleAndSize
3803
                                "locale", str, len,
3804
                                (Py_ssize_t)error_pos,
3805
                                (Py_ssize_t)(error_pos+1),
3806
                                reason);
3807
    Py_DECREF(reason);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeLocaleAndSize
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_DecodeLocaleAndSize
3808
    if (exc != NULL) {
3809
        PyCodec_StrictErrors(exc);
inline
        
PyCodec_StrictErrors will not be inlined into PyUnicode_DecodeLocaleAndSize because its definition is unavailable 
PyUnicode_DecodeLocaleAndSize
3810
        Py_XDECREF(exc);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeLocaleAndSize
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_DecodeLocaleAndSize
3811
    }
3812
    return NULL;
3813
}
3814
3815
PyObject*
3816
PyUnicode_DecodeLocale(const char *str, const char *errors)
3817
{
3818
    Py_ssize_t size = (Py_ssize_t)strlen(str);
inline
                                  
strlen will not be inlined into PyUnicode_DecodeLocale because its definition is unavailable 
PyUnicode_DecodeLocale
3819
    return PyUnicode_DecodeLocaleAndSize(str, size, errors);
inline
           
PyUnicode_DecodeLocaleAndSize too costly to inline (cost=655, threshold=625) 
PyUnicode_DecodeLocale
inline
           
PyUnicode_DecodeLocaleAndSize will not be inlined into PyUnicode_DecodeLocale 
PyUnicode_DecodeLocale
3820
}
3821
3822
3823
PyObject*
3824
PyUnicode_DecodeFSDefault(const char *s) {
3825
    Py_ssize_t size = (Py_ssize_t)strlen(s);
inline
                                  
strlen will not be inlined into PyUnicode_DecodeFSDefault because its definition is unavailable 
PyUnicode_DecodeFSDefault
3826
    return PyUnicode_DecodeFSDefaultAndSize(s, size);
inline
           
PyUnicode_DecodeFSDefaultAndSize can be inlined into PyUnicode_DecodeFSDefault with cost=100 (threshold=250) 
PyUnicode_DecodeFSDefault
inline
           
PyUnicode_DecodeFSDefaultAndSize inlined into PyUnicode_DecodeFSDefault 
PyUnicode_DecodeFSDefault
3827
}
3828
3829
PyObject*
3830
PyUnicode_DecodeFSDefaultAndSize(const char *s, Py_ssize_t size)
3831
{
3832
#if defined(__APPLE__)
3833
    return PyUnicode_DecodeUTF8Stateful(s, size, Py_FileSystemDefaultEncodeErrors, NULL);
3834
#else
3835
    PyInterpreterState *interp = PyThreadState_GET()->interp;
3836
    /* Bootstrap check: if the filesystem codec is implemented in Python, we
3837
       cannot use it to encode and decode filenames before it is loaded. Load
3838
       the Python codec requires to encode at least its own filename. Use the C
3839
       version of the locale codec until the codec registry is initialized and
3840
       the Python codec is loaded.
3841
3842
       Py_FileSystemDefaultEncoding is shared between all interpreters, we
3843
       cannot only rely on it: check also interp->fscodec_initialized for
3844
       subinterpreters. */
3845
    if (Py_FileSystemDefaultEncoding && interp->fscodec_initialized) {
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3846
        return PyUnicode_Decode(s, size,
inline
               
PyUnicode_Decode too costly to inline (cost=675, threshold=625) 
PyUnicode_DecodeFSDefaultAndSize
inline
               
PyUnicode_Decode will not be inlined into PyUnicode_DecodeFSDefaultAndSize 
PyUnicode_DecodeFSDefaultAndSize
inline
               
PyUnicode_Decode too costly to inline (cost=675, threshold=625) 
PyUnicode_DecodeFSDefault
inline
               
PyUnicode_Decode will not be inlined into PyUnicode_DecodeFSDefault 
PyUnicode_DecodeFSDefault
inline
               
PyUnicode_Decode too costly to inline (cost=675, threshold=625) 
PyUnicode_FSDecoder
inline
               
PyUnicode_Decode will not be inlined into PyUnicode_FSDecoder 
PyUnicode_FSDecoder
3847
                                Py_FileSystemDefaultEncoding,
3848
                                Py_FileSystemDefaultEncodeErrors);
gvn
                                
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
                                
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3849
    }
3850
    else {
3851
        return PyUnicode_DecodeLocaleAndSize(s, size, Py_FileSystemDefaultEncodeErrors);
inline
               
PyUnicode_DecodeLocaleAndSize too costly to inline (cost=655, threshold=625) 
PyUnicode_DecodeFSDefaultAndSize
inline
               
PyUnicode_DecodeLocaleAndSize will not be inlined into PyUnicode_DecodeFSDefaultAndSize 
PyUnicode_DecodeFSDefaultAndSize
inline
               
PyUnicode_DecodeLocaleAndSize too costly to inline (cost=655, threshold=625) 
PyUnicode_DecodeFSDefault
inline
               
PyUnicode_DecodeLocaleAndSize will not be inlined into PyUnicode_DecodeFSDefault 
PyUnicode_DecodeFSDefault
inline
               
PyUnicode_DecodeLocaleAndSize too costly to inline (cost=655, threshold=625) 
PyUnicode_FSDecoder
inline
               
PyUnicode_DecodeLocaleAndSize will not be inlined into PyUnicode_FSDecoder 
PyUnicode_FSDecoder
3852
    }
3853
#endif
3854
}
3855
3856
3857
int
3858
PyUnicode_FSConverter(PyObject* arg, void* addr)
3859
{
3860
    PyObject *path = NULL;
3861
    PyObject *output = NULL;
3862
    Py_ssize_t size;
3863
    void *data;
3864
    if (arg == NULL) {
3865
        Py_DECREF(*(PyObject**)addr);
3866
        *(PyObject**)addr = NULL;
3867
        return 1;
3868
    }
3869
    path = PyOS_FSPath(arg);
inline
           
PyOS_FSPath will not be inlined into PyUnicode_FSConverter because its definition is unavailable 
PyUnicode_FSConverter
3870
    if (path == NULL) {
3871
        return 0;
3872
    }
3873
    if (PyBytes_Check(path)) {
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FSConverter
3874
        output = path;
3875
    }
3876
    else {  // PyOS_FSPath() guarantees its returned value is bytes or str.
3877
        output = PyUnicode_EncodeFSDefault(path);
inline
                 
PyUnicode_EncodeFSDefault can be inlined into PyUnicode_FSConverter with cost=95 (threshold=250) 
PyUnicode_FSConverter
inline
                 
PyUnicode_EncodeFSDefault inlined into PyUnicode_FSConverter 
PyUnicode_FSConverter
3878
        Py_DECREF(path);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSConverter
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSConverter
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_FSConverter
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_FSConverter
3879
        if (!output) {
3880
            return 0;
3881
        }
3882
        assert(PyBytes_Check(output));
3883
    }
3884
3885
    size = PyBytes_GET_SIZE(output);
3886
    data = PyBytes_AS_STRING(output);
3887
    if ((size_t)size != strlen(data)) {
inline
                        
strlen will not be inlined into PyUnicode_FSConverter because its definition is unavailable 
PyUnicode_FSConverter
3888
        PyErr_SetString(PyExc_ValueError, "embedded null byte");
inline
        
PyErr_SetString will not be inlined into PyUnicode_FSConverter because its definition is unavailable 
PyUnicode_FSConverter
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FSConverter
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FSConverter
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FSConverter
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FSConverter
3889
        Py_DECREF(output);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSConverter
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FSConverter
3890
        return 0;
3891
    }
3892
    *(PyObject**)addr = output;
3893
    return Py_CLEANUP_SUPPORTED;
3894
}
3895
3896
3897
int
3898
PyUnicode_FSDecoder(PyObject* arg, void* addr)
3899
{
3900
    int is_buffer = 0;
3901
    PyObject *path = NULL;
3902
    PyObject *output = NULL;
3903
    if (arg == NULL) {
3904
        Py_DECREF(*(PyObject**)addr);
3905
        return 1;
3906
    }
3907
3908
    is_buffer = PyObject_CheckBuffer(arg);
3909
    if (!is_buffer) {
3910
        path = PyOS_FSPath(arg);
inline
               
PyOS_FSPath will not be inlined into PyUnicode_FSDecoder because its definition is unavailable 
PyUnicode_FSDecoder
3911
        if (path == NULL) {
3912
            return 0;
3913
        }
3914
    }
3915
    else {
3916
        path = arg;
3917
        Py_INCREF(arg);
3918
    }
3919
3920
    if (PyUnicode_Check(path)) {
gvn
        
load eliminated by PRE 
PyUnicode_FSDecoder
3921
        if (PyUnicode_READY(path) == -1) {
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_FSDecoder
inline
            
_PyUnicode_Ready will not be inlined into PyUnicode_FSDecoder 
PyUnicode_FSDecoder
3922
            Py_DECREF(path);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3923
            return 0;
3924
        }
3925
        output = path;
3926
    }
3927
    else if (PyBytes_Check(path) || is_buffer) {
3928
        PyObject *path_bytes = NULL;
3929
3930
        if (!PyBytes_Check(path) &&
3931
            PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
inline
            
PyErr_WarnFormat will not be inlined into PyUnicode_FSDecoder because its definition is unavailable 
PyUnicode_FSDecoder
gvn
                             
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3932
            "path should be string, bytes, or os.PathLike, not %.200s",
3933
            Py_TYPE(arg)->tp_name)) {
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_FSDecoder
3934
                Py_DECREF(path);
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
                
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3935
            return 0;
3936
        }
3937
        path_bytes = PyBytes_FromObject(path);
inline
                     
PyBytes_FromObject will not be inlined into PyUnicode_FSDecoder because its definition is unavailable 
PyUnicode_FSDecoder
3938
        Py_DECREF(path);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3939
        if (!path_bytes) {
3940
            return 0;
3941
        }
3942
        output = PyUnicode_DecodeFSDefaultAndSize(PyBytes_AS_STRING(path_bytes),
inline
                 
PyUnicode_DecodeFSDefaultAndSize can be inlined into PyUnicode_FSDecoder with cost=100 (threshold=250) 
PyUnicode_FSDecoder
inline
                 
PyUnicode_DecodeFSDefaultAndSize inlined into PyUnicode_FSDecoder 
PyUnicode_FSDecoder
3943
                                                  PyBytes_GET_SIZE(path_bytes));
gvn
                                                  
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
                                                  
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3944
        Py_DECREF(path_bytes);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3945
        if (!output) {
3946
            return 0;
3947
        }
3948
    }
3949
    else {
3950
        PyErr_Format(PyExc_TypeError,
inline
        
PyErr_Format will not be inlined into PyUnicode_FSDecoder because its definition is unavailable 
PyUnicode_FSDecoder
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3951
                     "path should be string, bytes, or os.PathLike, not %.200s",
3952
                     Py_TYPE(arg)->tp_name);
gvn
                     
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_FSDecoder
3953
        Py_DECREF(path);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3954
        return 0;
3955
    }
3956
    if (PyUnicode_READY(output) == -1) {
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_FSDecoder
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_FSDecoder 
PyUnicode_FSDecoder
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3957
        Py_DECREF(output);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3958
        return 0;
3959
    }
3960
    if (findchar(PyUnicode_DATA(output), PyUnicode_KIND(output),
inline
        
findchar can be inlined into PyUnicode_FSDecoder with cost=100 (threshold=325) 
PyUnicode_FSDecoder
inline
        
findchar inlined into PyUnicode_FSDecoder 
PyUnicode_FSDecoder
gvn
                 
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_FSDecoder
gvn
                 
load eliminated by PRE 
PyUnicode_FSDecoder
gvn
                 
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3961
                 PyUnicode_GET_LENGTH(output), 0, 1) >= 0) {
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3962
        PyErr_SetString(PyExc_ValueError, "embedded null character");
inline
        
PyErr_SetString will not be inlined into PyUnicode_FSDecoder because its definition is unavailable 
PyUnicode_FSDecoder
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3963
        Py_DECREF(output);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FSDecoder
3964
        return 0;
3965
    }
3966
    *(PyObject**)addr = output;
3967
    return Py_CLEANUP_SUPPORTED;
3968
}
3969
3970
3971
char*
3972
PyUnicode_AsUTF8AndSize(PyObject *unicode, Py_ssize_t *psize)
3973
{
3974
    PyObject *bytes;
3975
3976
    if (!PyUnicode_Check(unicode)) {
3977
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_AsUTF8AndSize because its definition is unavailable 
PyUnicode_AsUTF8AndSize
3978
        return NULL;
3979
    }
3980
    if (PyUnicode_READY(unicode) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_AsUTF8AndSize
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_AsUTF8AndSize 
PyUnicode_AsUTF8AndSize
3981
        return NULL;
3982
3983
    if (PyUnicode_UTF8(unicode) == NULL) {
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsUTF8AndSize
gvn
        
load eliminated by PRE 
PyUnicode_AsUTF8AndSize
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_AsUTF8AndSize
3984
        assert(!PyUnicode_IS_COMPACT_ASCII(unicode));
3985
        bytes = _PyUnicode_AsUTF8String(unicode, NULL);
inline
                
_PyUnicode_AsUTF8String too costly to inline (cost=635, threshold=625) 
PyUnicode_AsUTF8AndSize
inline
                
_PyUnicode_AsUTF8String will not be inlined into PyUnicode_AsUTF8AndSize 
PyUnicode_AsUTF8AndSize
3986
        if (bytes == NULL)
3987
            return NULL;
3988
        _PyUnicode_UTF8(unicode) = PyObject_MALLOC(PyBytes_GET_SIZE(bytes) + 1);
inline
                                   
PyObject_Malloc will not be inlined into PyUnicode_AsUTF8AndSize because its definition is unavailable 
PyUnicode_AsUTF8AndSize
gvn
                                                   
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsUTF8AndSize
3989
        if (_PyUnicode_UTF8(unicode) == NULL) {
3990
            PyErr_NoMemory();
inline
            
PyErr_NoMemory will not be inlined into PyUnicode_AsUTF8AndSize because its definition is unavailable 
PyUnicode_AsUTF8AndSize
3991
            Py_DECREF(bytes);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsUTF8AndSize
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_AsUTF8AndSize
3992
            return NULL;
3993
        }
3994
        _PyUnicode_UTF8_LENGTH(unicode) = PyBytes_GET_SIZE(bytes);
gvn
                                          
load of type i64 not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsUTF8AndSize
3995
        memcpy(_PyUnicode_UTF8(unicode),
gvn
               
load of type i8* eliminated in favor of call 
PyUnicode_AsUTF8AndSize
3996
                  PyBytes_AS_STRING(bytes),
3997
                  _PyUnicode_UTF8_LENGTH(unicode) + 1);
3998
        Py_DECREF(bytes);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsUTF8AndSize
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_AsUTF8AndSize
3999
    }
4000
4001
    if (psize)
4002
        *psize = PyUnicode_UTF8_LENGTH(unicode);
gvn
                 
load of type i32 not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsUTF8AndSize
gvn
                 
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsUTF8AndSize
4003
    return PyUnicode_UTF8(unicode);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsUTF8AndSize
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsUTF8AndSize
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsUTF8AndSize
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_AsUTF8AndSize
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_AsUTF8AndSize
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_AsUTF8AndSize
4004
}
4005
4006
char*
4007
PyUnicode_AsUTF8(PyObject *unicode)
4008
{
4009
    return PyUnicode_AsUTF8AndSize(unicode, NULL);
inline
           
PyUnicode_AsUTF8AndSize too costly to inline (cost=385, threshold=250) 
PyUnicode_AsUTF8
inline
           
PyUnicode_AsUTF8AndSize will not be inlined into PyUnicode_AsUTF8 
PyUnicode_AsUTF8
4010
}
4011
4012
Py_UNICODE *
4013
PyUnicode_AsUnicodeAndSize(PyObject *unicode, Py_ssize_t *size)
4014
{
4015
    const unsigned char *one_byte;
4016
#if SIZEOF_WCHAR_T == 4
4017
    const Py_UCS2 *two_bytes;
4018
#else
4019
    const Py_UCS4 *four_bytes;
4020
    const Py_UCS4 *ucs4_end;
4021
    Py_ssize_t num_surrogates;
4022
#endif
4023
    wchar_t *w;
4024
    wchar_t *wchar_end;
4025
4026
    if (!PyUnicode_Check(unicode)) {
4027
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_AsUnicodeAndSize because its definition is unavailable 
PyUnicode_AsUnicodeAndSize
4028
        return NULL;
4029
    }
4030
    if (_PyUnicode_WSTR(unicode) == NULL) {
4031
        /* Non-ASCII compact unicode object */
4032
        assert(_PyUnicode_KIND(unicode) != 0);
4033
        assert(PyUnicode_IS_READY(unicode));
4034
4035
        if (PyUnicode_KIND(unicode) == PyUnicode_4BYTE_KIND) {
4036
#if SIZEOF_WCHAR_T == 2
4037
            four_bytes = PyUnicode_4BYTE_DATA(unicode);
4038
            ucs4_end = four_bytes + _PyUnicode_LENGTH(unicode);
4039
            num_surrogates = 0;
4040
4041
            for (; four_bytes < ucs4_end; ++four_bytes) {
4042
                if (*four_bytes > 0xFFFF)
4043
                    ++num_surrogates;
4044
            }
4045
4046
            _PyUnicode_WSTR(unicode) = (wchar_t *) PyObject_MALLOC(
4047
                    sizeof(wchar_t) * (_PyUnicode_LENGTH(unicode) + 1 + num_surrogates));
4048
            if (!_PyUnicode_WSTR(unicode)) {
4049
                PyErr_NoMemory();
4050
                return NULL;
4051
            }
4052
            _PyUnicode_WSTR_LENGTH(unicode) = _PyUnicode_LENGTH(unicode) + num_surrogates;
4053
4054
            w = _PyUnicode_WSTR(unicode);
4055
            wchar_end = w + _PyUnicode_WSTR_LENGTH(unicode);
4056
            four_bytes = PyUnicode_4BYTE_DATA(unicode);
4057
            for (; four_bytes < ucs4_end; ++four_bytes, ++w) {
4058
                if (*four_bytes > 0xFFFF) {
4059
                    assert(*four_bytes <= MAX_UNICODE);
4060
                    /* encode surrogate pair in this case */
4061
                    *w++ = Py_UNICODE_HIGH_SURROGATE(*four_bytes);
4062
                    *w   = Py_UNICODE_LOW_SURROGATE(*four_bytes);
4063
                }
4064
                else
4065
                    *w = *four_bytes;
4066
4067
                if (w > wchar_end) {
4068
                    assert(0 && "Miscalculated string end");
4069
                }
4070
            }
4071
            *w = 0;
4072
#else
4073
            /* sizeof(wchar_t) == 4 */
4074
            Py_FatalError("Impossible unicode object state, wstr and str "
inline
            
Py_FatalError will not be inlined into PyUnicode_AsUnicodeAndSize because its definition is unavailable 
PyUnicode_AsUnicodeAndSize
4075
                          "should share memory already.");
4076
            return NULL;
4077
#endif
4078
        }
4079
        else {
4080
            if ((size_t)_PyUnicode_LENGTH(unicode) >
4081
                    PY_SSIZE_T_MAX / sizeof(wchar_t) - 1) {
4082
                PyErr_NoMemory();
inline
                
PyErr_NoMemory will not be inlined into PyUnicode_AsUnicodeAndSize because its definition is unavailable 
PyUnicode_AsUnicodeAndSize
4083
                return NULL;
4084
            }
4085
            _PyUnicode_WSTR(unicode) = (wchar_t *) PyObject_MALLOC(sizeof(wchar_t) *
inline
                                                   
PyObject_Malloc will not be inlined into PyUnicode_AsUnicodeAndSize because its definition is unavailable 
PyUnicode_AsUnicodeAndSize
4086
                                                  (_PyUnicode_LENGTH(unicode) + 1));
4087
            if (!_PyUnicode_WSTR(unicode)) {
4088
                PyErr_NoMemory();
inline
                
PyErr_NoMemory will not be inlined into PyUnicode_AsUnicodeAndSize because its definition is unavailable 
PyUnicode_AsUnicodeAndSize
4089
                return NULL;
4090
            }
4091
            if (!PyUnicode_IS_COMPACT_ASCII(unicode))
gvn
                 
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsUnicodeAndSize
4092
                _PyUnicode_WSTR_LENGTH(unicode) = _PyUnicode_LENGTH(unicode);
gvn
                                                  
load of type i64 not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsUnicodeAndSize
4093
            w = _PyUnicode_WSTR(unicode);
gvn
                
load of type i32* eliminated in favor of inttoptr 
PyUnicode_AsUnicodeAndSize
4094
            wchar_end = w + _PyUnicode_LENGTH(unicode);
gvn
                            
load of type i64 not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsUnicodeAndSize
gvn
                            
load eliminated by PRE 
PyUnicode_AsUnicodeAndSize
4095
4096
            if (PyUnicode_KIND(unicode) == PyUnicode_1BYTE_KIND) {
4097
                one_byte = PyUnicode_1BYTE_DATA(unicode);
gvn
                           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_AsUnicodeAndSize
4098
                for (; w < wchar_end; ++one_byte, ++w)
loop-vectorize
                
loop not vectorized: could not determine number of loop iterations 
PyUnicode_AsUnicodeAndSize
loop-vectorize
                
loop not vectorized 
PyUnicode_AsUnicodeAndSize
4099
                    *w = *one_byte;
gvn
                         
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeAndSize
4100
                /* null-terminate the wstr */
4101
                *w = 0;
4102
            }
4103
            else if (PyUnicode_KIND(unicode) == PyUnicode_2BYTE_KIND) {
4104
#if SIZEOF_WCHAR_T == 4
4105
                two_bytes = PyUnicode_2BYTE_DATA(unicode);
gvn
                            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_AsUnicodeAndSize
4106
                for (; w < wchar_end; ++two_bytes, ++w)
loop-vectorize
                
loop not vectorized: could not determine number of loop iterations 
PyUnicode_AsUnicodeAndSize
loop-vectorize
                
loop not vectorized 
PyUnicode_AsUnicodeAndSize
4107
                    *w = *two_bytes;
4108
                /* null-terminate the wstr */
4109
                *w = 0;
4110
#else
4111
                /* sizeof(wchar_t) == 2 */
4112
                PyObject_FREE(_PyUnicode_WSTR(unicode));
4113
                _PyUnicode_WSTR(unicode) = NULL;
4114
                Py_FatalError("Impossible unicode object state, wstr "
4115
                              "and str should share memory already.");
4116
                return NULL;
4117
#endif
4118
            }
4119
            else {
4120
                assert(0 && "This should never happen.");
4121
            }
4122
        }
4123
    }
4124
    if (size != NULL)
4125
        *size = PyUnicode_WSTR_LENGTH(unicode);
gvn
                
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeAndSize
gvn
                
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeAndSize
4126
    return _PyUnicode_WSTR(unicode);
gvn
           
load of type i32* eliminated in favor of phi 
PyUnicode_AsUnicodeAndSize
4127
}
4128
4129
Py_UNICODE *
4130
PyUnicode_AsUnicode(PyObject *unicode)
4131
{
4132
    return PyUnicode_AsUnicodeAndSize(unicode, NULL);
inline
           
PyUnicode_AsUnicodeAndSize too costly to inline (cost=410, threshold=250) 
PyUnicode_AsUnicode
inline
           
PyUnicode_AsUnicodeAndSize will not be inlined into PyUnicode_AsUnicode 
PyUnicode_AsUnicode
inline
           
PyUnicode_AsUnicodeAndSize too costly to inline (cost=410, threshold=250) 
PyUnicode_GetSize
inline
           
PyUnicode_AsUnicodeAndSize will not be inlined into PyUnicode_GetSize 
PyUnicode_GetSize
4133
}
4134
4135
4136
Py_ssize_t
4137
PyUnicode_GetSize(PyObject *unicode)
4138
{
4139
    if (!PyUnicode_Check(unicode)) {
4140
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_GetSize because its definition is unavailable 
PyUnicode_GetSize
4141
        goto onError;
4142
    }
4143
    return PyUnicode_GET_SIZE(unicode);
inline
           
PyUnicode_AsUnicode can be inlined into PyUnicode_GetSize with cost=5 (threshold=375) 
PyUnicode_GetSize
inline
           
PyUnicode_AsUnicode inlined into PyUnicode_GetSize 
PyUnicode_GetSize
4144
4145
  onError:
4146
    return -1;
4147
}
4148
4149
Py_ssize_t
4150
PyUnicode_GetLength(PyObject *unicode)
4151
{
4152
    if (!PyUnicode_Check(unicode)) {
4153
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_GetLength because its definition is unavailable 
PyUnicode_GetLength
4154
        return -1;
4155
    }
4156
    if (PyUnicode_READY(unicode) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_GetLength
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_GetLength 
PyUnicode_GetLength
4157
        return -1;
4158
    return PyUnicode_GET_LENGTH(unicode);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_GetLength
4159
}
4160
4161
Py_UCS4
4162
PyUnicode_ReadChar(PyObject *unicode, Py_ssize_t index)
4163
{
4164
    void *data;
4165
    int kind;
4166
4167
    if (!PyUnicode_Check(unicode) || PyUnicode_READY(unicode) == -1) {
inline
                                     
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_ReadChar
inline
                                     
_PyUnicode_Ready will not be inlined into PyUnicode_ReadChar 
PyUnicode_ReadChar
4168
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_ReadChar because its definition is unavailable 
PyUnicode_ReadChar
4169
        return (Py_UCS4)-1;
4170
    }
4171
    if (index < 0 || index >= PyUnicode_GET_LENGTH(unicode)) {
gvn
                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_ReadChar
4172
        PyErr_SetString(PyExc_IndexError, "string index out of range");
inline
        
PyErr_SetString will not be inlined into PyUnicode_ReadChar because its definition is unavailable 
PyUnicode_ReadChar
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_ReadChar
4173
        return (Py_UCS4)-1;
4174
    }
4175
    data = PyUnicode_DATA(unicode);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_ReadChar
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_ReadChar
4176
    kind = PyUnicode_KIND(unicode);
4177
    return PyUnicode_READ(kind, data, index);
4178
}
4179
4180
int
4181
PyUnicode_WriteChar(PyObject *unicode, Py_ssize_t index, Py_UCS4 ch)
4182
{
4183
    if (!PyUnicode_Check(unicode) || !PyUnicode_IS_COMPACT(unicode)) {
4184
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_WriteChar because its definition is unavailable 
PyUnicode_WriteChar
4185
        return -1;
4186
    }
4187
    assert(PyUnicode_IS_READY(unicode));
4188
    if (index < 0 || index >= PyUnicode_GET_LENGTH(unicode)) {
4189
        PyErr_SetString(PyExc_IndexError, "string index out of range");
inline
        
PyErr_SetString will not be inlined into PyUnicode_WriteChar because its definition is unavailable 
PyUnicode_WriteChar
4190
        return -1;
4191
    }
4192
    if (unicode_check_modifiable(unicode))
inline
        
unicode_check_modifiable can be inlined into PyUnicode_WriteChar with cost=-14925 (threshold=250) 
PyUnicode_WriteChar
inline
        
unicode_check_modifiable inlined into PyUnicode_WriteChar 
PyUnicode_WriteChar
4193
        return -1;
4194
    if (ch > PyUnicode_MAX_CHAR_VALUE(unicode)) {
gvn
             
load of type i32 eliminated in favor of load 
PyUnicode_WriteChar
4195
        PyErr_SetString(PyExc_ValueError, "character out of range");
inline
        
PyErr_SetString will not be inlined into PyUnicode_WriteChar because its definition is unavailable 
PyUnicode_WriteChar
4196
        return -1;
4197
    }
4198
    PyUnicode_WRITE(PyUnicode_KIND(unicode), PyUnicode_DATA(unicode),
4199
                    index, ch);
4200
    return 0;
4201
}
4202
4203
const char *
4204
PyUnicode_GetDefaultEncoding(void)
4205
{
4206
    return "utf-8";
4207
}
4208
4209
/* create or adjust a UnicodeDecodeError */
4210
static void
4211
make_decode_exception(PyObject **exceptionObject,
4212
                      const char *encoding,
4213
                      const char *input, Py_ssize_t length,
4214
                      Py_ssize_t startpos, Py_ssize_t endpos,
4215
                      const char *reason)
4216
{
4217
    if (*exceptionObject == NULL) {
gvn
        
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_decode_call_errorhandler_writer
4218
        *exceptionObject = PyUnicodeDecodeError_Create(
inline
                           
PyUnicodeDecodeError_Create will not be inlined into make_decode_exception because its definition is unavailable 
make_decode_exception
4219
            encoding, input, length, startpos, endpos, reason);
4220
    }
4221
    else {
4222
        if (PyUnicodeDecodeError_SetStart(*exceptionObject, startpos))
inline
            
PyUnicodeDecodeError_SetStart will not be inlined into make_decode_exception because its definition is unavailable 
make_decode_exception
4223
            goto onError;
4224
        if (PyUnicodeDecodeError_SetEnd(*exceptionObject, endpos))
inline
            
PyUnicodeDecodeError_SetEnd will not be inlined into make_decode_exception because its definition is unavailable 
make_decode_exception
gvn
                                        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
make_decode_exception
gvn
                                        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4225
            goto onError;
4226
        if (PyUnicodeDecodeError_SetReason(*exceptionObject, reason))
inline
            
PyUnicodeDecodeError_SetReason will not be inlined into make_decode_exception because its definition is unavailable 
make_decode_exception
gvn
                                           
load of type %struct._object* not eliminated because it is clobbered by call 
make_decode_exception
gvn
                                           
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4227
            goto onError;
4228
    }
4229
    return;
4230
4231
onError:
4232
    Py_CLEAR(*exceptionObject);
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
make_decode_exception
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
make_decode_exception
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
make_decode_exception
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by store 
make_decode_exception
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_decode_call_errorhandler_writer
4233
}
4234
4235
#ifdef MS_WINDOWS
4236
/* error handling callback helper:
4237
   build arguments, call the callback and check the arguments,
4238
   if no exception occurred, copy the replacement to the output
4239
   and adjust various state variables.
4240
   return 0 on success, -1 on error
4241
*/
4242
4243
static int
4244
unicode_decode_call_errorhandler_wchar(
4245
    const char *errors, PyObject **errorHandler,
4246
    const char *encoding, const char *reason,
4247
    const char **input, const char **inend, Py_ssize_t *startinpos,
4248
    Py_ssize_t *endinpos, PyObject **exceptionObject, const char **inptr,
4249
    PyObject **output, Py_ssize_t *outpos)
4250
{
4251
    static const char *argparse = "O!n;decoding error handler must return (str, int) tuple";
4252
4253
    PyObject *restuple = NULL;
4254
    PyObject *repunicode = NULL;
4255
    Py_ssize_t outsize;
4256
    Py_ssize_t insize;
4257
    Py_ssize_t requiredsize;
4258
    Py_ssize_t newpos;
4259
    PyObject *inputobj = NULL;
4260
    wchar_t *repwstr;
4261
    Py_ssize_t repwlen;
4262
4263
    assert (_PyUnicode_KIND(*output) == PyUnicode_WCHAR_KIND);
4264
    outsize = _PyUnicode_WSTR_LENGTH(*output);
4265
4266
    if (*errorHandler == NULL) {
4267
        *errorHandler = PyCodec_LookupError(errors);
4268
        if (*errorHandler == NULL)
4269
            goto onError;
4270
    }
4271
4272
    make_decode_exception(exceptionObject,
4273
        encoding,
4274
        *input, *inend - *input,
4275
        *startinpos, *endinpos,
4276
        reason);
4277
    if (*exceptionObject == NULL)
4278
        goto onError;
4279
4280
    restuple = PyObject_CallFunctionObjArgs(*errorHandler, *exceptionObject, NULL);
4281
    if (restuple == NULL)
4282
        goto onError;
4283
    if (!PyTuple_Check(restuple)) {
4284
        PyErr_SetString(PyExc_TypeError, &argparse[4]);
4285
        goto onError;
4286
    }
4287
    if (!PyArg_ParseTuple(restuple, argparse, &PyUnicode_Type, &repunicode, &newpos))
4288
        goto onError;
4289
4290
    /* Copy back the bytes variables, which might have been modified by the
4291
       callback */
4292
    inputobj = PyUnicodeDecodeError_GetObject(*exceptionObject);
4293
    if (!inputobj)
4294
        goto onError;
4295
    if (!PyBytes_Check(inputobj)) {
4296
        PyErr_Format(PyExc_TypeError, "exception attribute object must be bytes");
4297
    }
4298
    *input = PyBytes_AS_STRING(inputobj);
4299
    insize = PyBytes_GET_SIZE(inputobj);
4300
    *inend = *input + insize;
4301
    /* we can DECREF safely, as the exception has another reference,
4302
       so the object won't go away. */
4303
    Py_DECREF(inputobj);
4304
4305
    if (newpos<0)
4306
        newpos = insize+newpos;
4307
    if (newpos<0 || newpos>insize) {
4308
        PyErr_Format(PyExc_IndexError, "position %zd from error handler out of bounds", newpos);
4309
        goto onError;
4310
    }
4311
4312
    repwstr = PyUnicode_AsUnicodeAndSize(repunicode, &repwlen);
4313
    if (repwstr == NULL)
4314
        goto onError;
4315
    /* need more space? (at least enough for what we
4316
       have+the replacement+the rest of the string (starting
4317
       at the new input position), so we won't have to check space
4318
       when there are no errors in the rest of the string) */
4319
    requiredsize = *outpos;
4320
    if (requiredsize > PY_SSIZE_T_MAX - repwlen)
4321
        goto overflow;
4322
    requiredsize += repwlen;
4323
    if (requiredsize > PY_SSIZE_T_MAX - (insize - newpos))
4324
        goto overflow;
4325
    requiredsize += insize - newpos;
4326
    if (requiredsize > outsize) {
4327
        if (outsize <= PY_SSIZE_T_MAX/2 && requiredsize < 2*outsize)
4328
            requiredsize = 2*outsize;
4329
        if (unicode_resize(output, requiredsize) < 0)
4330
            goto onError;
4331
    }
4332
    wcsncpy(_PyUnicode_WSTR(*output) + *outpos, repwstr, repwlen);
4333
    *outpos += repwlen;
4334
    *endinpos = newpos;
4335
    *inptr = *input + newpos;
4336
4337
    /* we made it! */
4338
    Py_XDECREF(restuple);
4339
    return 0;
4340
4341
  overflow:
4342
    PyErr_SetString(PyExc_OverflowError,
4343
                    "decoded result is too long for a Python string");
4344
4345
  onError:
4346
    Py_XDECREF(restuple);
4347
    return -1;
4348
}
4349
#endif   /* MS_WINDOWS */
4350
4351
static int
4352
unicode_decode_call_errorhandler_writer(
4353
    const char *errors, PyObject **errorHandler,
4354
    const char *encoding, const char *reason,
4355
    const char **input, const char **inend, Py_ssize_t *startinpos,
4356
    Py_ssize_t *endinpos, PyObject **exceptionObject, const char **inptr,
4357
    _PyUnicodeWriter *writer /* PyObject **output, Py_ssize_t *outpos */)
4358
{
4359
    static const char *argparse = "O!n;decoding error handler must return (str, int) tuple";
4360
4361
    PyObject *restuple = NULL;
4362
    PyObject *repunicode = NULL;
4363
    Py_ssize_t insize;
4364
    Py_ssize_t newpos;
4365
    Py_ssize_t replen;
4366
    PyObject *inputobj = NULL;
4367
4368
    if (*errorHandler == NULL) {
4369
        *errorHandler = PyCodec_LookupError(errors);
inline
                        
PyCodec_LookupError will not be inlined into unicode_decode_call_errorhandler_writer because its definition is unavailable 
unicode_decode_call_errorhandler_writer
4370
        if (*errorHandler == NULL)
4371
            goto onError;
4372
    }
4373
4374
    make_decode_exception(exceptionObject,
inline
    
make_decode_exception can be inlined into unicode_decode_call_errorhandler_writer with cost=-14760 (threshold=250) 
unicode_decode_call_errorhandler_writer
inline
    
make_decode_exception inlined into unicode_decode_call_errorhandler_writer 
unicode_decode_call_errorhandler_writer
4375
        encoding,
4376
        *input, *inend - *input,
gvn
        
load of type i8* not eliminated because it is clobbered by store 
unicode_decode_call_errorhandler_writer
gvn
                
load of type i64 not eliminated because it is clobbered by store 
unicode_decode_call_errorhandler_writer
4377
        *startinpos, *endinpos,
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
                     
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4378
        reason);
4379
    if (*exceptionObject == NULL)
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4380
        goto onError;
4381
4382
    restuple = PyObject_CallFunctionObjArgs(*errorHandler, *exceptionObject, NULL);
inline
               
PyObject_CallFunctionObjArgs will not be inlined into unicode_decode_call_errorhandler_writer because its definition is unavailable 
unicode_decode_call_errorhandler_writer
gvn
                                            
load of type %struct._object* not eliminated in favor of load because it is clobbered by store 
unicode_decode_call_errorhandler_writer
gvn
                                            
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
                                            
load of type %struct._object* not eliminated in favor of load because it is clobbered by store 
unicode_decode_call_errorhandler_writer
gvn
                                            
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4383
    if (restuple == NULL)
4384
        goto onError;
4385
    if (!PyTuple_Check(restuple)) {
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4386
        PyErr_SetString(PyExc_TypeError, &argparse[4]);
inline
        
PyErr_SetString will not be inlined into unicode_decode_call_errorhandler_writer because its definition is unavailable 
unicode_decode_call_errorhandler_writer
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4387
        goto onError;
4388
    }
4389
    if (!PyArg_ParseTuple(restuple, argparse, &PyUnicode_Type, &repunicode, &newpos))
inline
         
_PyArg_ParseTuple_SizeT will not be inlined into unicode_decode_call_errorhandler_writer because its definition is unavailable 
unicode_decode_call_errorhandler_writer
4390
        goto onError;
4391
4392
    /* Copy back the bytes variables, which might have been modified by the
4393
       callback */
4394
    inputobj = PyUnicodeDecodeError_GetObject(*exceptionObject);
inline
               
PyUnicodeDecodeError_GetObject will not be inlined into unicode_decode_call_errorhandler_writer because its definition is unavailable 
unicode_decode_call_errorhandler_writer
gvn
                                              
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4395
    if (!inputobj)
4396
        goto onError;
4397
    if (!PyBytes_Check(inputobj)) {
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4398
        PyErr_Format(PyExc_TypeError, "exception attribute object must be bytes");
inline
        
PyErr_Format will not be inlined into unicode_decode_call_errorhandler_writer because its definition is unavailable 
unicode_decode_call_errorhandler_writer
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4399
    }
4400
    *input = PyBytes_AS_STRING(inputobj);
4401
    insize = PyBytes_GET_SIZE(inputobj);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4402
    *inend = *input + insize;
4403
    /* we can DECREF safely, as the exception has another reference,
4404
       so the object won't go away. */
4405
    Py_DECREF(inputobj);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by store 
unicode_decode_call_errorhandler_writer
4406
4407
    if (newpos<0)
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
        
load of type i64 not eliminated because it is clobbered by store 
unicode_decode_call_errorhandler_writer
4408
        newpos = insize+newpos;
4409
    if (newpos<0 || newpos>insize) {
gvn
        
load of type i64 eliminated in favor of phi 
unicode_decode_call_errorhandler_writer
4410
        PyErr_Format(PyExc_IndexError, "position %zd from error handler out of bounds", newpos);
inline
        
PyErr_Format will not be inlined into unicode_decode_call_errorhandler_writer because its definition is unavailable 
unicode_decode_call_errorhandler_writer
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_decode_call_errorhandler_writer
4411
        goto onError;
4412
    }
4413
4414
    if (PyUnicode_READY(repunicode) < 0)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_decode_call_errorhandler_writer
inline
        
_PyUnicode_Ready will not be inlined into unicode_decode_call_errorhandler_writer 
unicode_decode_call_errorhandler_writer
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4415
        goto onError;
4416
    replen = PyUnicode_GET_LENGTH(repunicode);
gvn
             
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
             
load eliminated by PRE 
unicode_decode_call_errorhandler_writer
4417
    if (replen > 1) {
4418
        writer->min_length += replen - 1;
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4419
        writer->overallocate = 1;
4420
        if (_PyUnicodeWriter_Prepare(writer, writer->min_length,
inline
            
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
unicode_decode_call_errorhandler_writer
inline
            
_PyUnicodeWriter_PrepareInternal will not be inlined into unicode_decode_call_errorhandler_writer 
unicode_decode_call_errorhandler_writer
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_decode_call_errorhandler_writer
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
            
load of type i64 eliminated in favor of add 
unicode_decode_call_errorhandler_writer
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
            
load of type %struct.PyASCIIObject* eliminated in favor of phi 
unicode_decode_call_errorhandler_writer
4421
                            PyUnicode_MAX_CHAR_VALUE(repunicode)) == -1)
4422
            goto onError;
4423
    }
4424
    if (_PyUnicodeWriter_WriteStr(writer, repunicode) == -1)
inline
        
_PyUnicodeWriter_WriteStr too costly to inline (cost=445, threshold=250) 
unicode_decode_call_errorhandler_writer
inline
        
_PyUnicodeWriter_WriteStr will not be inlined into unicode_decode_call_errorhandler_writer 
unicode_decode_call_errorhandler_writer
gvn
                                          
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
                                          
load eliminated by PRE 
unicode_decode_call_errorhandler_writer
4425
        goto onError;
4426
4427
    *endinpos = newpos;
gvn
                
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4428
    *inptr = *input + newpos;
gvn
             
load of type i8* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4429
4430
    /* we made it! */
4431
    Py_XDECREF(restuple);
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_decode_call_errorhandler_writer
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by store 
unicode_decode_call_errorhandler_writer
4432
    return 0;
4433
4434
  onError:
4435
    Py_XDECREF(restuple);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_decode_call_errorhandler_writer
4436
    return -1;
4437
}
4438
4439
/* --- UTF-7 Codec -------------------------------------------------------- */
4440
4441
/* See RFC2152 for details.  We encode conservatively and decode liberally. */
4442
4443
/* Three simple macros defining base-64. */
4444
4445
/* Is c a base-64 character? */
4446
4447
#define IS_BASE64(c) \
4448
    (((c) >= 'A' && (c) <= 'Z') ||     \
4449
     ((c) >= 'a' && (c) <= 'z') ||     \
4450
     ((c) >= '0' && (c) <= '9') ||     \
4451
     (c) == '+' || (c) == '/')
4452
4453
/* given that c is a base-64 character, what is its base-64 value? */
4454
4455
#define FROM_BASE64(c)                                                  \
4456
    (((c) >= 'A' && (c) <= 'Z') ? (c) - 'A' :                           \
4457
     ((c) >= 'a' && (c) <= 'z') ? (c) - 'a' + 26 :                      \
4458
     ((c) >= '0' && (c) <= '9') ? (c) - '0' + 52 :                      \
4459
     (c) == '+' ? 62 : 63)
4460
4461
/* What is the base-64 character of the bottom 6 bits of n? */
4462
4463
#define TO_BASE64(n)  \
4464
    ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[(n) & 0x3f])
4465
4466
/* DECODE_DIRECT: this byte encountered in a UTF-7 string should be
4467
 * decoded as itself.  We are permissive on decoding; the only ASCII
4468
 * byte not decoding to itself is the + which begins a base64
4469
 * string. */
4470
4471
#define DECODE_DIRECT(c)                                \
4472
    ((c) <= 127 && (c) != '+')
4473
4474
/* The UTF-7 encoder treats ASCII characters differently according to
4475
 * whether they are Set D, Set O, Whitespace, or special (i.e. none of
4476
 * the above).  See RFC2152.  This array identifies these different
4477
 * sets:
4478
 * 0 : "Set D"
4479
 *     alphanumeric and '(),-./:?
4480
 * 1 : "Set O"
4481
 *     !"#$%&*;<=>@[]^_`{|}
4482
 * 2 : "whitespace"
4483
 *     ht nl cr sp
4484
 * 3 : special (must be base64 encoded)
4485
 *     everything else (i.e. +\~ and non-printing codes 0-8 11-12 14-31 127)
4486
 */
4487
4488
static
4489
char utf7_category[128] = {
4490
/* nul soh stx etx eot enq ack bel bs  ht  nl  vt  np  cr  so  si  */
4491
    3,  3,  3,  3,  3,  3,  3,  3,  3,  2,  2,  3,  3,  2,  3,  3,
4492
/* dle dc1 dc2 dc3 dc4 nak syn etb can em  sub esc fs  gs  rs  us  */
4493
    3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
4494
/* sp   !   "   #   $   %   &   '   (   )   *   +   ,   -   .   /  */
4495
    2,  1,  1,  1,  1,  1,  1,  0,  0,  0,  1,  3,  0,  0,  0,  0,
4496
/*  0   1   2   3   4   5   6   7   8   9   :   ;   <   =   >   ?  */
4497
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,  0,
4498
/*  @   A   B   C   D   E   F   G   H   I   J   K   L   M   N   O  */
4499
    1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
4500
/*  P   Q   R   S   T   U   V   W   X   Y   Z   [   \   ]   ^   _  */
4501
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  3,  1,  1,  1,
4502
/*  `   a   b   c   d   e   f   g   h   i   j   k   l   m   n   o  */
4503
    1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
4504
/*  p   q   r   s   t   u   v   w   x   y   z   {   |   }   ~  del */
4505
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  3,  3,
4506
};
4507
4508
/* ENCODE_DIRECT: this character should be encoded as itself.  The
4509
 * answer depends on whether we are encoding set O as itself, and also
4510
 * on whether we are encoding whitespace as itself.  RFC2152 makes it
4511
 * clear that the answers to these questions vary between
4512
 * applications, so this code needs to be flexible.  */
4513
4514
#define ENCODE_DIRECT(c, directO, directWS)             \
4515
    ((c) < 128 && (c) > 0 &&                            \
4516
     ((utf7_category[(c)] == 0) ||                      \
4517
      (directWS && (utf7_category[(c)] == 2)) ||        \
4518
      (directO && (utf7_category[(c)] == 1))))
4519
4520
PyObject *
4521
PyUnicode_DecodeUTF7(const char *s,
4522
                     Py_ssize_t size,
4523
                     const char *errors)
4524
{
4525
    return PyUnicode_DecodeUTF7Stateful(s, size, errors, NULL);
inline
           
PyUnicode_DecodeUTF7Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF7
inline
           
PyUnicode_DecodeUTF7Stateful will not be inlined into PyUnicode_DecodeUTF7 
PyUnicode_DecodeUTF7
4526
}
4527
4528
/* The decoder.  The only state we preserve is our read position,
4529
 * i.e. how many characters we have consumed.  So if we end in the
4530
 * middle of a shift sequence we have to back off the read position
4531
 * and the output to the beginning of the sequence, otherwise we lose
4532
 * all the shift state (seen bits, number of bits seen, high
4533
 * surrogate). */
4534
4535
PyObject *
4536
PyUnicode_DecodeUTF7Stateful(const char *s,
4537
                             Py_ssize_t size,
4538
                             const char *errors,
4539
                             Py_ssize_t *consumed)
4540
{
4541
    const char *starts = s;
4542
    Py_ssize_t startinpos;
4543
    Py_ssize_t endinpos;
4544
    const char *e;
4545
    _PyUnicodeWriter writer;
4546
    const char *errmsg = "";
4547
    int inShift = 0;
4548
    Py_ssize_t shiftOutStart;
4549
    unsigned int base64bits = 0;
4550
    unsigned long base64buffer = 0;
4551
    Py_UCS4 surrogate = 0;
4552
    PyObject *errorHandler = NULL;
4553
    PyObject *exc = NULL;
4554
4555
    if (size == 0) {
4556
        if (consumed)
4557
            *consumed = 0;
4558
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_DecodeUTF7Stateful
inline
        
PyUnicode_New will not be inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
gvn
        
load of type %struct._object* eliminated in favor of phi 
PyUnicode_DecodeUTF7Stateful
4559
    }
4560
4561
    /* Start off assuming it's all ASCII. Widen later as necessary. */
4562
    _PyUnicodeWriter_Init(&writer);
inline
    
_PyUnicodeWriter_Init can be inlined into PyUnicode_DecodeUTF7Stateful with cost=-30 (threshold=375) 
PyUnicode_DecodeUTF7Stateful
inline
    
_PyUnicodeWriter_Init inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
4563
    writer.min_length = size;
4564
4565
    shiftOutStart = 0;
4566
    e = s + size;
gvn
        
load of type i8* eliminated in favor of  
PyUnicode_DecodeUTF7Stateful
4567
4568
    while (s < e) {
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
licm
               
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
gvn
           
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
           
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
           
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
           
load eliminated by PRE 
PyUnicode_DecodeUTF7Stateful
gvn
               
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
               
load eliminated by PRE 
PyUnicode_DecodeUTF7Stateful
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeUTF7Stateful
loop-vectorize
    
loop not vectorized 
PyUnicode_DecodeUTF7Stateful
4569
        Py_UCS4 ch;
4570
      restart:
4571
        ch = (unsigned char) *s;
licm
                              
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
gvn
                              
load of type i8* eliminated in favor of load 
PyUnicode_DecodeUTF7Stateful
gvn
                              
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF7Stateful
gvn
                             
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
                             
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
                             
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
                             
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
4572
4573
        if (inShift) { /* in a base-64 section */
4574
            if (IS_BASE64(ch)) { /* consume a base-64 character */
4575
                base64buffer = (base64buffer << 6) | FROM_BASE64(ch);
4576
                base64bits += 6;
4577
                s++;
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
gvn
                 
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF7Stateful
4578
                if (base64bits >= 16) {
4579
                    /* we have enough bits for a UTF-16 value */
4580
                    Py_UCS4 outCh = (Py_UCS4)(base64buffer >> (base64bits-16));
4581
                    base64bits -= 16;
4582
                    base64buffer &= (1 << base64bits) - 1; /* clear high bits */
4583
                    assert(outCh <= 0xffff);
4584
                    if (surrogate) {
4585
                        /* expecting a second surrogate */
4586
                        if (Py_UNICODE_IS_LOW_SURROGATE(outCh)) {
4587
                            Py_UCS4 ch2 = Py_UNICODE_JOIN_SURROGATES(surrogate, outCh);
4588
                            if (_PyUnicodeWriter_WriteCharInline(&writer, ch2) < 0)
inline
                                
_PyUnicodeWriter_WriteCharInline can be inlined into PyUnicode_DecodeUTF7Stateful with cost=150 (threshold=325) 
PyUnicode_DecodeUTF7Stateful
inline
                                
_PyUnicodeWriter_WriteCharInline inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
4589
                                goto onError;
4590
                            surrogate = 0;
4591
                            continue;
4592
                        }
4593
                        else {
4594
                            if (_PyUnicodeWriter_WriteCharInline(&writer, surrogate) < 0)
inline
                                
_PyUnicodeWriter_WriteCharInline can be inlined into PyUnicode_DecodeUTF7Stateful with cost=150 (threshold=325) 
PyUnicode_DecodeUTF7Stateful
inline
                                
_PyUnicodeWriter_WriteCharInline inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
4595
                                goto onError;
4596
                            surrogate = 0;
4597
                        }
4598
                    }
4599
                    if (Py_UNICODE_IS_HIGH_SURROGATE(outCh)) {
4600
                        /* first surrogate */
4601
                        surrogate = outCh;
4602
                    }
4603
                    else {
4604
                        if (_PyUnicodeWriter_WriteCharInline(&writer, outCh) < 0)
inline
                            
_PyUnicodeWriter_WriteCharInline can be inlined into PyUnicode_DecodeUTF7Stateful with cost=150 (threshold=325) 
PyUnicode_DecodeUTF7Stateful
inline
                            
_PyUnicodeWriter_WriteCharInline inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
4605
                            goto onError;
4606
                    }
4607
                }
4608
            }
4609
            else { /* now leaving a base-64 section */
4610
                inShift = 0;
4611
                if (base64bits > 0) { /* left-over bits */
4612
                    if (base64bits >= 6) {
4613
                        /* We've seen at least one base-64 character */
4614
                        s++;
4615
                        errmsg = "partial character in shift sequence";
4616
                        goto utf7Error;
4617
                    }
4618
                    else {
4619
                        /* Some bits remain; they should be zero */
4620
                        if (base64buffer != 0) {
4621
                            s++;
4622
                            errmsg = "non-zero padding bits in shift sequence";
4623
                            goto utf7Error;
4624
                        }
4625
                    }
4626
                }
4627
                if (surrogate && DECODE_DIRECT(ch)) {
4628
                    if (_PyUnicodeWriter_WriteCharInline(&writer, surrogate) < 0)
inline
                        
_PyUnicodeWriter_WriteCharInline can be inlined into PyUnicode_DecodeUTF7Stateful with cost=150 (threshold=325) 
PyUnicode_DecodeUTF7Stateful
inline
                        
_PyUnicodeWriter_WriteCharInline inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
4629
                        goto onError;
4630
                }
4631
                surrogate = 0;
4632
                if (ch == '-') {
4633
                    /* '-' is absorbed; other terminating
4634
                       characters are preserved */
4635
                    s++;
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
gvn
                     
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF7Stateful
4636
                }
4637
            }
4638
        }
4639
        else if ( ch == '+' ) {
4640
            startinpos = s-starts;
licm
                           
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4641
            s++; /* consume '+' */
licm
             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
gvn
             
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF7Stateful
4642
            if (s < e && *s == '-') { /* '+-' encodes '+' */
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
gvn
                    
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF7Stateful
gvn
                         
load of type i8 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
4643
                s++;
4644
                if (_PyUnicodeWriter_WriteCharInline(&writer, '+') < 0)
inline
                    
_PyUnicodeWriter_WriteCharInline can be inlined into PyUnicode_DecodeUTF7Stateful with cost=150 (threshold=325) 
PyUnicode_DecodeUTF7Stateful
inline
                    
_PyUnicodeWriter_WriteCharInline inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
4645
                    goto onError;
4646
            }
4647
            else { /* begin base64-encoded section */
4648
                inShift = 1;
4649
                surrogate = 0;
4650
                shiftOutStart = writer.pos;
licm
                                       
hosting getelementptr 
PyUnicode_DecodeUTF7Stateful
licm
                                       
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
gvn
                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4651
                base64bits = 0;
4652
                base64buffer = 0;
4653
            }
4654
        }
4655
        else if (DECODE_DIRECT(ch)) { /* character decodes as itself */
4656
            s++;
4657
            if (_PyUnicodeWriter_WriteCharInline(&writer, ch) < 0)
inline
                
_PyUnicodeWriter_WriteCharInline can be inlined into PyUnicode_DecodeUTF7Stateful with cost=150 (threshold=325) 
PyUnicode_DecodeUTF7Stateful
inline
                
_PyUnicodeWriter_WriteCharInline inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
4658
                goto onError;
4659
        }
4660
        else {
4661
            startinpos = s-starts;
licm
                           
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4662
            s++;
licm
             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
gvn
             
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF7Stateful
4663
            errmsg = "unexpected special character";
4664
            goto utf7Error;
4665
        }
4666
        continue;
4667
utf7Error:
4668
        endinpos = s-starts;
licm
                   
hosting bitcast 
PyUnicode_DecodeUTF7Stateful
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
gvn
                   
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF7Stateful
gvn
                     
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                     
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4669
        if (unicode_decode_call_errorhandler_writer(
inline
            
unicode_decode_call_errorhandler_writer too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF7Stateful
inline
            
unicode_decode_call_errorhandler_writer will not be inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
4670
                errors, &errorHandler,
4671
                "utf7", errmsg,
4672
                &starts, &e, &startinpos, &endinpos, &exc, &s,
4673
                &writer))
4674
            goto onError;
4675
    }
4676
4677
    /* end of string */
4678
4679
    if (inShift && !consumed) { /* in shift sequence, no more to follow */
licm
                    
hosting icmp 
PyUnicode_DecodeUTF7Stateful
4680
        /* if we're in an inconsistent state, that's an error */
4681
        inShift = 0;
4682
        if (surrogate ||
4683
                (base64bits >= 6) ||
4684
                (base64bits > 0 && base64buffer != 0)) {
4685
            endinpos = size;
4686
            if (unicode_decode_call_errorhandler_writer(
inline
                
unicode_decode_call_errorhandler_writer too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF7Stateful
inline
                
unicode_decode_call_errorhandler_writer will not be inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
4687
                    errors, &errorHandler,
4688
                    "utf7", "unterminated shift sequence",
4689
                    &starts, &e, &startinpos, &endinpos, &exc, &s,
4690
                    &writer))
4691
                goto onError;
4692
            if (s < e)
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                    
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4693
                goto restart;
4694
        }
4695
    }
4696
4697
    /* return state */
4698
    if (consumed) {
4699
        if (inShift) {
4700
            *consumed = startinpos;
gvn
                        
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF7Stateful
4701
            if (writer.pos != shiftOutStart && writer.maxchar > 127) {
gvn
                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                       
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                                                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
                                                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                                                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                                                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4702
                PyObject *result = PyUnicode_FromKindAndData(
inline
                                   
PyUnicode_FromKindAndData can be inlined into PyUnicode_DecodeUTF7Stateful with cost=195 (threshold=250) 
PyUnicode_DecodeUTF7Stateful
inline
                                   
PyUnicode_FromKindAndData inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
4703
                        writer.kind, writer.data, shiftOutStart);
gvn
                                            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
                                            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                                            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                               
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
                               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4704
                Py_XDECREF(errorHandler);
gvn
                
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4705
                Py_XDECREF(exc);
gvn
                
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4706
                _PyUnicodeWriter_Dealloc(&writer);
inline
                
_PyUnicodeWriter_Dealloc can be inlined into PyUnicode_DecodeUTF7Stateful with cost=20 (threshold=250) 
PyUnicode_DecodeUTF7Stateful
inline
                
_PyUnicodeWriter_Dealloc inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
4707
                return result;
4708
            }
4709
            writer.pos = shiftOutStart; /* back off output */
4710
        }
4711
        else {
4712
            *consumed = s-starts;
gvn
                        
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF7Stateful
gvn
                          
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
                          
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4713
        }
4714
    }
4715
4716
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4717
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4718
    return _PyUnicodeWriter_Finish(&writer);
inline
           
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
PyUnicode_DecodeUTF7Stateful
inline
           
_PyUnicodeWriter_Finish will not be inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
4719
4720
  onError:
4721
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4722
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
4723
    _PyUnicodeWriter_Dealloc(&writer);
inline
    
_PyUnicodeWriter_Dealloc can be inlined into PyUnicode_DecodeUTF7Stateful with cost=20 (threshold=250) 
PyUnicode_DecodeUTF7Stateful
inline
    
_PyUnicodeWriter_Dealloc inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
4724
    return NULL;
4725
}
4726
4727
4728
PyObject *
4729
_PyUnicode_EncodeUTF7(PyObject *str,
4730
                      int base64SetO,
4731
                      int base64WhiteSpace,
4732
                      const char *errors)
4733
{
4734
    int kind;
4735
    void *data;
4736
    Py_ssize_t len;
4737
    PyObject *v;
4738
    int inShift = 0;
4739
    Py_ssize_t i;
4740
    unsigned int base64bits = 0;
4741
    unsigned long base64buffer = 0;
4742
    char * out;
4743
    char * start;
4744
4745
    if (PyUnicode_READY(str) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeUTF7
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_EncodeUTF7 
_PyUnicode_EncodeUTF7
4746
        return NULL;
4747
    kind = PyUnicode_KIND(str);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF7
gvn
           
load eliminated by PRE 
_PyUnicode_EncodeUTF7
4748
    data = PyUnicode_DATA(str);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF7
4749
    len = PyUnicode_GET_LENGTH(str);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF7
4750
4751
    if (len == 0)
4752
        return PyBytes_FromStringAndSize(NULL, 0);
inline
               
PyBytes_FromStringAndSize will not be inlined into _PyUnicode_EncodeUTF7 because its definition is unavailable 
_PyUnicode_EncodeUTF7
4753
4754
    /* It might be possible to tighten this worst case */
4755
    if (len > PY_SSIZE_T_MAX / 8)
4756
        return PyErr_NoMemory();
inline
               
PyErr_NoMemory will not be inlined into _PyUnicode_EncodeUTF7 because its definition is unavailable 
_PyUnicode_EncodeUTF7
4757
    v = PyBytes_FromStringAndSize(NULL, len * 8);
inline
        
PyBytes_FromStringAndSize will not be inlined into _PyUnicode_EncodeUTF7 because its definition is unavailable 
_PyUnicode_EncodeUTF7
4758
    if (v == NULL)
4759
        return NULL;
4760
4761
    start = out = PyBytes_AS_STRING(v);
4762
    for (i = 0; i < len; ++i) {
4763
        Py_UCS4 ch = PyUnicode_READ(kind, data, i);
licm
                     
hosting trunc 
_PyUnicode_EncodeUTF7
licm
                     
hosting bitcast 
_PyUnicode_EncodeUTF7
gvn
                     
load of type i16 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF7
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_EncodeUTF7
gvn
                     
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF7
4764
4765
        if (inShift) {
4766
            if (ENCODE_DIRECT(ch, !base64SetO, !base64WhiteSpace)) {
licm
                
hosting icmp 
_PyUnicode_EncodeUTF7
4767
                /* shifting out */
4768
                if (base64bits) { /* output remaining bits */
4769
                    *out++ = TO_BASE64(base64buffer << (6-base64bits));
4770
                    base64buffer = 0;
4771
                    base64bits = 0;
4772
                }
4773
                inShift = 0;
4774
                /* Characters not in the BASE64 set implicitly unshift the sequence
4775
                   so no '-' is required, except if the character is itself a '-' */
4776
                if (IS_BASE64(ch) || ch == '-') {
4777
                    *out++ = '-';
4778
                }
4779
                *out++ = (char) ch;
4780
            }
4781
            else {
4782
                goto encode_char;
4783
            }
4784
        }
4785
        else { /* not in a shift sequence */
4786
            if (ch == '+') {
4787
                *out++ = '+';
4788
                        *out++ = '-';
4789
            }
4790
            else if (ENCODE_DIRECT(ch, !base64SetO, !base64WhiteSpace)) {
licm
                     
hosting icmp 
_PyUnicode_EncodeUTF7
4791
                *out++ = (char) ch;
4792
            }
4793
            else {
4794
                *out++ = '+';
4795
                inShift = 1;
4796
                goto encode_char;
4797
            }
4798
        }
4799
        continue;
4800
encode_char:
4801
        if (ch >= 0x10000) {
4802
            assert(ch <= MAX_UNICODE);
4803
4804
            /* code first surrogate */
4805
            base64bits += 16;
4806
            base64buffer = (base64buffer << 16) | Py_UNICODE_HIGH_SURROGATE(ch);
4807
            while (base64bits >= 6) {
loop-vectorize
            
loop not vectorized 
_PyUnicode_EncodeUTF7
4808
                *out++ = TO_BASE64(base64buffer >> (base64bits-6));
loop-vectorize
                         
loop not vectorized: value cannot be used outside the loop 
_PyUnicode_EncodeUTF7
4809
                base64bits -= 6;
4810
            }
4811
            /* prepare second surrogate */
4812
            ch = Py_UNICODE_LOW_SURROGATE(ch);
4813
        }
4814
        base64bits += 16;
4815
        base64buffer = (base64buffer << 16) | ch;
4816
        while (base64bits >= 6) {
loop-vectorize
        
loop not vectorized 
_PyUnicode_EncodeUTF7
4817
            *out++ = TO_BASE64(base64buffer >> (base64bits-6));
loop-vectorize
                     
loop not vectorized: value cannot be used outside the loop 
_PyUnicode_EncodeUTF7
4818
            base64bits -= 6;
4819
        }
4820
    }
4821
    if (base64bits)
4822
        *out++= TO_BASE64(base64buffer << (6-base64bits) );
4823
    if (inShift)
4824
        *out++ = '-';
4825
    if (_PyBytes_Resize(&v, out - start) < 0)
inline
        
_PyBytes_Resize will not be inlined into _PyUnicode_EncodeUTF7 because its definition is unavailable 
_PyUnicode_EncodeUTF7
4826
        return NULL;
4827
    return v;
gvn
           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF7
4828
}
4829
PyObject *
4830
PyUnicode_EncodeUTF7(const Py_UNICODE *s,
4831
                     Py_ssize_t size,
4832
                     int base64SetO,
4833
                     int base64WhiteSpace,
4834
                     const char *errors)
4835
{
4836
    PyObject *result;
4837
    PyObject *tmp = PyUnicode_FromUnicode(s, size);
inline
                    
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeUTF7
inline
                    
PyUnicode_FromUnicode will not be inlined into PyUnicode_EncodeUTF7 
PyUnicode_EncodeUTF7
4838
    if (tmp == NULL)
4839
        return NULL;
4840
    result = _PyUnicode_EncodeUTF7(tmp, base64SetO,
inline
             
_PyUnicode_EncodeUTF7 too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeUTF7
inline
             
_PyUnicode_EncodeUTF7 will not be inlined into PyUnicode_EncodeUTF7 
PyUnicode_EncodeUTF7
4841
                                   base64WhiteSpace, errors);
4842
    Py_DECREF(tmp);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeUTF7
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeUTF7
4843
    return result;
4844
}
4845
4846
#undef IS_BASE64
4847
#undef FROM_BASE64
4848
#undef TO_BASE64
4849
#undef DECODE_DIRECT
4850
#undef ENCODE_DIRECT
4851
4852
/* --- UTF-8 Codec -------------------------------------------------------- */
4853
4854
PyObject *
4855
PyUnicode_DecodeUTF8(const char *s,
4856
                     Py_ssize_t size,
4857
                     const char *errors)
4858
{
4859
    return PyUnicode_DecodeUTF8Stateful(s, size, errors, NULL);
inline
           
PyUnicode_DecodeUTF8Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF8
inline
           
PyUnicode_DecodeUTF8Stateful will not be inlined into PyUnicode_DecodeUTF8 
PyUnicode_DecodeUTF8
4860
}
4861
4862
#include "stringlib/asciilib.h"
4863
#include "stringlib/codecs.h"
4864
#include "stringlib/undef.h"
4865
4866
#include "stringlib/ucs1lib.h"
4867
#include "stringlib/codecs.h"
4868
#include "stringlib/undef.h"
4869
4870
#include "stringlib/ucs2lib.h"
4871
#include "stringlib/codecs.h"
4872
#include "stringlib/undef.h"
4873
4874
#include "stringlib/ucs4lib.h"
4875
#include "stringlib/codecs.h"
4876
#include "stringlib/undef.h"
4877
4878
/* Mask to quickly check whether a C 'long' contains a
4879
   non-ASCII, UTF8-encoded char. */
4880
#if (SIZEOF_LONG == 8)
4881
# define ASCII_CHAR_MASK 0x8080808080808080UL
4882
#elif (SIZEOF_LONG == 4)
4883
# define ASCII_CHAR_MASK 0x80808080UL
4884
#else
4885
# error C 'long' size should be either 4 or 8!
4886
#endif
4887
4888
static Py_ssize_t
4889
ascii_decode(const char *start, const char *end, Py_UCS1 *dest)
4890
{
4891
    const char *p = start;
4892
    const char *aligned_end = (const char *) _Py_ALIGN_DOWN(end, SIZEOF_LONG);
4893
4894
    /*
4895
     * Issue #17237: m68k is a bit different from most architectures in
4896
     * that objects do not use "natural alignment" - for example, int and
4897
     * long are only aligned at 2-byte boundaries.  Therefore the assert()
4898
     * won't work; also, tests have shown that skipping the "optimised
4899
     * version" will even speed up m68k.
4900
     */
4901
#if !defined(__m68k__)
4902
#if SIZEOF_LONG <= SIZEOF_VOID_P
4903
    assert(_Py_IS_ALIGNED(dest, SIZEOF_LONG));
4904
    if (_Py_IS_ALIGNED(p, SIZEOF_LONG)) {
4905
        /* Fast path, see in STRINGLIB(utf8_decode) for
4906
           an explanation. */
4907
        /* Help allocation */
4908
        const char *_p = p;
4909
        Py_UCS1 * q = dest;
4910
        while (_p < aligned_end) {
4911
            unsigned long value = *(const unsigned long *) _p;
loop-vectorize
                                  
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeUTF8Stateful
loop-vectorize
                                  
loop not vectorized 
PyUnicode_DecodeUTF8Stateful
loop-vectorize
                                  
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeASCII
loop-vectorize
                                  
loop not vectorized 
PyUnicode_DecodeASCII
4912
            if (value & ASCII_CHAR_MASK)
4913
                break;
4914
            *((unsigned long *)q) = value;
4915
            _p += SIZEOF_LONG;
4916
            q += SIZEOF_LONG;
4917
        }
4918
        p = _p;
4919
        while (p < end) {
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeUTF8Stateful
loop-vectorize
        
loop not vectorized 
PyUnicode_DecodeUTF8Stateful
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeASCII
loop-vectorize
        
loop not vectorized 
PyUnicode_DecodeASCII
4920
            if ((unsigned char)*p & 0x80)
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
ascii_decode
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
ascii_decode
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeASCII
gvn
                               
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
                               
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeASCII
4921
                break;
4922
            *q++ = *p++;
4923
        }
4924
        return p - start;
4925
    }
4926
#endif
4927
#endif
4928
    while (p < end) {
4929
        /* Fast path, see in STRINGLIB(utf8_decode) in stringlib/codecs.h
4930
           for an explanation. */
4931
        if (_Py_IS_ALIGNED(p, SIZEOF_LONG)) {
4932
            /* Help allocation */
4933
            const char *_p = p;
4934
            while (_p < aligned_end) {
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeUTF8Stateful
loop-vectorize
            
loop not vectorized 
PyUnicode_DecodeUTF8Stateful
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeASCII
loop-vectorize
            
loop not vectorized 
PyUnicode_DecodeASCII
4935
                unsigned long value = *(unsigned long *) _p;
4936
                if (value & ASCII_CHAR_MASK)
4937
                    break;
4938
                _p += SIZEOF_LONG;
4939
            }
4940
            p = _p;
4941
            if (_p == end)
4942
                break;
4943
        }
4944
        if ((unsigned char)*p & 0x80)
gvn
                           
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                           
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeASCII
4945
            break;
4946
        ++p;
4947
    }
4948
    memcpy(dest, start, p - start);
4949
    return p - start;
4950
}
4951
4952
PyObject *
4953
PyUnicode_DecodeUTF8Stateful(const char *s,
4954
                             Py_ssize_t size,
4955
                             const char *errors,
4956
                             Py_ssize_t *consumed)
4957
{
4958
    _PyUnicodeWriter writer;
4959
    const char *starts = s;
4960
    const char *end = s + size;
gvn
                      
load of type i8* eliminated in favor of  
PyUnicode_DecodeUTF8Stateful
4961
4962
    Py_ssize_t startinpos;
4963
    Py_ssize_t endinpos;
4964
    const char *errmsg = "";
4965
    PyObject *error_handler_obj = NULL;
4966
    PyObject *exc = NULL;
4967
    _Py_error_handler error_handler = _Py_ERROR_UNKNOWN;
4968
4969
    if (size == 0) {
4970
        if (consumed)
4971
            *consumed = 0;
4972
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_DecodeUTF8Stateful
inline
        
PyUnicode_New will not be inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type %struct._object* eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
4973
    }
4974
4975
    /* ASCII is equivalent to the first 128 ordinals in Unicode. */
4976
    if (size == 1 && (unsigned char)s[0] < 128) {
gvn
                                    
load of type i8* eliminated in favor of  
PyUnicode_DecodeUTF8Stateful
4977
        if (consumed)
4978
            *consumed = 1;
4979
        return get_latin1_char((unsigned char)s[0]);
inline
               
get_latin1_char can be inlined into PyUnicode_DecodeUTF8Stateful with cost=110 (threshold=250) 
PyUnicode_DecodeUTF8Stateful
inline
               
get_latin1_char inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
gvn
                                              
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                                              
load eliminated by PRE 
PyUnicode_DecodeUTF8Stateful
4980
    }
4981
4982
    _PyUnicodeWriter_Init(&writer);
inline
    
_PyUnicodeWriter_Init can be inlined into PyUnicode_DecodeUTF8Stateful with cost=-30 (threshold=375) 
PyUnicode_DecodeUTF8Stateful
inline
    
_PyUnicodeWriter_Init inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
4983
    writer.min_length = size;
4984
    if (_PyUnicodeWriter_Prepare(&writer, writer.min_length, 127) == -1)
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF8Stateful
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 eliminated in favor of 0 
PyUnicode_DecodeUTF8Stateful
4985
        goto onError;
4986
4987
    writer.pos = ascii_decode(s, end, writer.data);
inline
                 
ascii_decode can be inlined into PyUnicode_DecodeUTF8Stateful with cost=165 (threshold=250) 
PyUnicode_DecodeUTF8Stateful
inline
                 
ascii_decode inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
gvn
                              
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                              
load eliminated by PRE 
PyUnicode_DecodeUTF8Stateful
gvn
                                 
load of type i8* eliminated in favor of getelementptr 
PyUnicode_DecodeUTF8Stateful
gvn
                                             
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                                             
load eliminated by PRE 
PyUnicode_DecodeUTF8Stateful
4988
    s += writer.pos;
gvn
      
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
      
load eliminated by PRE 
PyUnicode_DecodeUTF8Stateful
4989
    while (s < end) {
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
               
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
gvn
               
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
               
load eliminated by PRE 
PyUnicode_DecodeUTF8Stateful
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
           
load eliminated by PRE 
PyUnicode_DecodeUTF8Stateful
gvn
               
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
               
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
               
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
               
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
           
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
4990
        Py_UCS4 ch;
4991
        int kind = writer.kind;
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
4992
4993
        if (kind == PyUnicode_1BYTE_KIND) {
4994
            if (PyUnicode_IS_ASCII(writer.buffer))
licm
                
hosting bitcast 
PyUnicode_DecodeUTF8Stateful
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
4995
                ch = asciilib_utf8_decode(&s, end, writer.data, &writer.pos);
inline
                     
asciilib_utf8_decode can be inlined into PyUnicode_DecodeUTF8Stateful with cost=-14245 (threshold=325) 
PyUnicode_DecodeUTF8Stateful
inline
                     
asciilib_utf8_decode inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
4996
            else
4997
                ch = ucs1lib_utf8_decode(&s, end, writer.data, &writer.pos);
inline
                     
ucs1lib_utf8_decode can be inlined into PyUnicode_DecodeUTF8Stateful with cost=-14235 (threshold=325) 
PyUnicode_DecodeUTF8Stateful
inline
                     
ucs1lib_utf8_decode inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
4998
        } else if (kind == PyUnicode_2BYTE_KIND) {
4999
            ch = ucs2lib_utf8_decode(&s, end, writer.data, &writer.pos);
inline
                 
ucs2lib_utf8_decode can be inlined into PyUnicode_DecodeUTF8Stateful with cost=-14205 (threshold=325) 
PyUnicode_DecodeUTF8Stateful
inline
                 
ucs2lib_utf8_decode inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
5000
        } else {
5001
            assert(kind == PyUnicode_4BYTE_KIND);
5002
            ch = ucs4lib_utf8_decode(&s, end, writer.data, &writer.pos);
inline
                 
ucs4lib_utf8_decode can be inlined into PyUnicode_DecodeUTF8Stateful with cost=-14190 (threshold=325) 
PyUnicode_DecodeUTF8Stateful
inline
                 
ucs4lib_utf8_decode inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
5003
        }
5004
5005
        switch (ch) {
5006
        case 0:
5007
            if (s == end || consumed)
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
                            
hosting icmp 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
gvn
                     
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                     
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                     
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
5008
                goto End;
5009
            errmsg = "unexpected end of data";
5010
            startinpos = s - starts;
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
5011
            endinpos = end - starts;
5012
            break;
5013
        case 1:
5014
            errmsg = "invalid start byte";
5015
            startinpos = s - starts;
licm
                         
hosting bitcast 
PyUnicode_DecodeUTF8Stateful
licm
                         
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
gvn
                         
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
5016
            endinpos = startinpos + 1;
5017
            break;
5018
        case 2:
5019
        case 3:
5020
        case 4:
5021
            errmsg = "invalid continuation byte";
5022
            startinpos = s - starts;
licm
                         
hosting bitcast 
PyUnicode_DecodeUTF8Stateful
licm
                         
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
gvn
                         
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
5023
            endinpos = startinpos + ch - 1;
5024
            break;
5025
        default:
5026
            if (_PyUnicodeWriter_WriteCharInline(&writer, ch) < 0)
inline
                
_PyUnicodeWriter_WriteCharInline can be inlined into PyUnicode_DecodeUTF8Stateful with cost=150 (threshold=325) 
PyUnicode_DecodeUTF8Stateful
inline
                
_PyUnicodeWriter_WriteCharInline inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
5027
                goto onError;
5028
            continue;
5029
        }
5030
5031
        if (error_handler == _Py_ERROR_UNKNOWN)
5032
            error_handler = get_error_handler(errors);
inline
                            
get_error_handler too costly to inline (cost=325, threshold=250) 
PyUnicode_DecodeUTF8Stateful
inline
                            
get_error_handler will not be inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
5033
5034
        switch (error_handler) {
5035
        case _Py_ERROR_IGNORE:
5036
            s += (endinpos - startinpos);
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
              
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
gvn
                  
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
gvn
              
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
5037
            break;
5038
5039
        case _Py_ERROR_REPLACE:
5040
            if (_PyUnicodeWriter_WriteCharInline(&writer, 0xfffd) < 0)
inline
                
_PyUnicodeWriter_WriteCharInline can be inlined into PyUnicode_DecodeUTF8Stateful with cost=150 (threshold=325) 
PyUnicode_DecodeUTF8Stateful
inline
                
_PyUnicodeWriter_WriteCharInline inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
5041
                goto onError;
5042
            s += (endinpos - startinpos);
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
              
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
gvn
                  
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
gvn
              
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
5043
            break;
5044
5045
        case _Py_ERROR_SURROGATEESCAPE:
5046
        {
5047
            Py_ssize_t i;
5048
5049
            if (_PyUnicodeWriter_PrepareKind(&writer, PyUnicode_2BYTE_KIND) < 0)
inline
                
_PyUnicodeWriter_PrepareKindInternal can be inlined into PyUnicode_DecodeUTF8Stateful with cost=5 (threshold=375) 
PyUnicode_DecodeUTF8Stateful
inline
                
_PyUnicodeWriter_PrepareKindInternal inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
5050
                goto onError;
5051
            for (i=startinpos; i<endinpos; i++) {
licm
                                 
hosting load 
PyUnicode_DecodeUTF8Stateful
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
                                 
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
gvn
                   
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
gvn
                                 
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
loop-vectorize
            
loop not vectorized 
PyUnicode_DecodeUTF8Stateful
5052
                ch = (Py_UCS4)(unsigned char)(starts[i]);
licm
                                              
hosting load 
PyUnicode_DecodeUTF8Stateful
5053
                PyUnicode_WRITE(writer.kind, writer.data, writer.pos,
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
                
hosting bitcast 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
loop-vectorize
                
loop not vectorized: loop contains a switch statement 
PyUnicode_DecodeUTF8Stateful
5054
                                ch + 0xdc00);
5055
                writer.pos++;
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
gvn
                          
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
5056
            }
5057
            s += (endinpos - startinpos);
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
              
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
gvn
                             
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
gvn
              
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
5058
            break;
5059
        }
5060
5061
        default:
5062
            if (unicode_decode_call_errorhandler_writer(
inline
                
unicode_decode_call_errorhandler_writer too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF8Stateful
inline
                
unicode_decode_call_errorhandler_writer will not be inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
5063
                    errors, &error_handler_obj,
5064
                    "utf-8", errmsg,
5065
                    &starts, &end, &startinpos, &endinpos, &exc, &s,
5066
                    &writer))
5067
                goto onError;
5068
        }
5069
    }
5070
5071
End:
5072
    if (consumed)
5073
        *consumed = s - starts;
gvn
                    
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
gvn
                        
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                        
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                        
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
                        
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
                        
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
5074
5075
    Py_XDECREF(error_handler_obj);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
5076
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
5077
    return _PyUnicodeWriter_Finish(&writer);
inline
           
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
PyUnicode_DecodeUTF8Stateful
inline
           
_PyUnicodeWriter_Finish will not be inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
5078
5079
onError:
5080
    Py_XDECREF(error_handler_obj);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
5081
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
5082
    _PyUnicodeWriter_Dealloc(&writer);
inline
    
_PyUnicodeWriter_Dealloc can be inlined into PyUnicode_DecodeUTF8Stateful with cost=20 (threshold=250) 
PyUnicode_DecodeUTF8Stateful
inline
    
_PyUnicodeWriter_Dealloc inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
5083
    return NULL;
5084
}
5085
5086
#ifdef __APPLE__
5087
5088
/* Simplified UTF-8 decoder using surrogateescape error handler,
5089
   used to decode the command line arguments on Mac OS X.
5090
5091
   Return a pointer to a newly allocated wide character string (use
5092
   PyMem_RawFree() to free the memory), or NULL on memory allocation error. */
5093
5094
wchar_t*
5095
_Py_DecodeUTF8_surrogateescape(const char *s, Py_ssize_t size)
5096
{
5097
    const char *e;
5098
    wchar_t *unicode;
5099
    Py_ssize_t outpos;
5100
5101
    /* Note: size will always be longer than the resulting Unicode
5102
       character count */
5103
    if (PY_SSIZE_T_MAX / (Py_ssize_t)sizeof(wchar_t) < (size + 1))
5104
        return NULL;
5105
    unicode = PyMem_RawMalloc((size + 1) * sizeof(wchar_t));
5106
    if (!unicode)
5107
        return NULL;
5108
5109
    /* Unpack UTF-8 encoded data */
5110
    e = s + size;
5111
    outpos = 0;
5112
    while (s < e) {
5113
        Py_UCS4 ch;
5114
#if SIZEOF_WCHAR_T == 4
5115
        ch = ucs4lib_utf8_decode(&s, e, (Py_UCS4 *)unicode, &outpos);
5116
#else
5117
        ch = ucs2lib_utf8_decode(&s, e, (Py_UCS2 *)unicode, &outpos);
5118
#endif
5119
        if (ch > 0xFF) {
5120
#if SIZEOF_WCHAR_T == 4
5121
            assert(0);
5122
#else
5123
            assert(ch > 0xFFFF && ch <= MAX_UNICODE);
5124
            /*  compute and append the two surrogates: */
5125
            unicode[outpos++] = (wchar_t)Py_UNICODE_HIGH_SURROGATE(ch);
5126
            unicode[outpos++] = (wchar_t)Py_UNICODE_LOW_SURROGATE(ch);
5127
#endif
5128
        }
5129
        else {
5130
            if (!ch && s == e)
5131
                break;
5132
            /* surrogateescape */
5133
            unicode[outpos++] = 0xDC00 + (unsigned char)*s++;
5134
        }
5135
    }
5136
    unicode[outpos] = L'\0';
5137
    return unicode;
5138
}
5139
5140
#endif /* __APPLE__ */
5141
5142
/* Primary internal function which creates utf8 encoded bytes objects.
5143
5144
   Allocation strategy:  if the string is short, convert into a stack buffer
5145
   and allocate exactly as much space needed at the end.  Else allocate the
5146
   maximum possible needed (4 result bytes per Unicode character), and return
5147
   the excess memory at the end.
5148
*/
5149
PyObject *
5150
_PyUnicode_AsUTF8String(PyObject *unicode, const char *errors)
5151
{
5152
    enum PyUnicode_Kind kind;
5153
    void *data;
5154
    Py_ssize_t size;
5155
5156
    if (!PyUnicode_Check(unicode)) {
5157
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into _PyUnicode_AsUTF8String because its definition is unavailable 
_PyUnicode_AsUTF8String
5158
        return NULL;
5159
    }
5160
5161
    if (PyUnicode_READY(unicode) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_AsUTF8String
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_AsUTF8String 
_PyUnicode_AsUTF8String
5162
        return NULL;
5163
5164
    if (PyUnicode_UTF8(unicode))
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_AsUTF8String
gvn
        
load eliminated by PRE 
_PyUnicode_AsUTF8String
gvn
        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_AsUTF8String
5165
        return PyBytes_FromStringAndSize(PyUnicode_UTF8(unicode),
inline
               
PyBytes_FromStringAndSize will not be inlined into _PyUnicode_AsUTF8String because its definition is unavailable 
_PyUnicode_AsUTF8String
gvn
                                         
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_AsUTF8String
5166
                                         PyUnicode_UTF8_LENGTH(unicode));
gvn
                                         
load of type i32 eliminated in favor of phi 
_PyUnicode_AsUTF8String
5167
5168
    kind = PyUnicode_KIND(unicode);
5169
    data = PyUnicode_DATA(unicode);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_AsUTF8String
5170
    size = PyUnicode_GET_LENGTH(unicode);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_AsUTF8String
5171
5172
    switch (kind) {
5173
    default:
5174
        assert(0);
5175
    case PyUnicode_1BYTE_KIND:
5176
        /* the string cannot be ASCII, or PyUnicode_UTF8() would be set */
5177
        assert(!PyUnicode_IS_ASCII(unicode));
5178
        return ucs1lib_utf8_encoder(unicode, data, size, errors);
inline
               
ucs1lib_utf8_encoder can be inlined into _PyUnicode_AsUTF8String with cost=-14785 (threshold=325) 
_PyUnicode_AsUTF8String
inline
               
ucs1lib_utf8_encoder inlined into _PyUnicode_AsUTF8String 
_PyUnicode_AsUTF8String
5179
    case PyUnicode_2BYTE_KIND:
5180
        return ucs2lib_utf8_encoder(unicode, data, size, errors);
inline
               
ucs2lib_utf8_encoder can be inlined into _PyUnicode_AsUTF8String with cost=-13190 (threshold=325) 
_PyUnicode_AsUTF8String
inline
               
ucs2lib_utf8_encoder inlined into _PyUnicode_AsUTF8String 
_PyUnicode_AsUTF8String
5181
    case PyUnicode_4BYTE_KIND:
5182
        return ucs4lib_utf8_encoder(unicode, data, size, errors);
inline
               
ucs4lib_utf8_encoder can be inlined into _PyUnicode_AsUTF8String with cost=-13140 (threshold=325) 
_PyUnicode_AsUTF8String
inline
               
ucs4lib_utf8_encoder inlined into _PyUnicode_AsUTF8String 
_PyUnicode_AsUTF8String
5183
    }
5184
}
5185
5186
PyObject *
5187
PyUnicode_EncodeUTF8(const Py_UNICODE *s,
5188
                     Py_ssize_t size,
5189
                     const char *errors)
5190
{
5191
    PyObject *v, *unicode;
5192
5193
    unicode = PyUnicode_FromUnicode(s, size);
inline
              
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeUTF8
inline
              
PyUnicode_FromUnicode will not be inlined into PyUnicode_EncodeUTF8 
PyUnicode_EncodeUTF8
5194
    if (unicode == NULL)
5195
        return NULL;
5196
    v = _PyUnicode_AsUTF8String(unicode, errors);
inline
        
_PyUnicode_AsUTF8String too costly to inline (cost=635, threshold=625) 
PyUnicode_EncodeUTF8
inline
        
_PyUnicode_AsUTF8String will not be inlined into PyUnicode_EncodeUTF8 
PyUnicode_EncodeUTF8
5197
    Py_DECREF(unicode);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeUTF8
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeUTF8
5198
    return v;
5199
}
5200
5201
PyObject *
5202
PyUnicode_AsUTF8String(PyObject *unicode)
5203
{
5204
    return _PyUnicode_AsUTF8String(unicode, NULL);
inline
           
_PyUnicode_AsUTF8String too costly to inline (cost=635, threshold=625) 
PyUnicode_AsUTF8String
inline
           
_PyUnicode_AsUTF8String will not be inlined into PyUnicode_AsUTF8String 
PyUnicode_AsUTF8String
5205
}
5206
5207
/* --- UTF-32 Codec ------------------------------------------------------- */
5208
5209
PyObject *
5210
PyUnicode_DecodeUTF32(const char *s,
5211
                      Py_ssize_t size,
5212
                      const char *errors,
5213
                      int *byteorder)
5214
{
5215
    return PyUnicode_DecodeUTF32Stateful(s, size, errors, byteorder, NULL);
inline
           
PyUnicode_DecodeUTF32Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF32
inline
           
PyUnicode_DecodeUTF32Stateful will not be inlined into PyUnicode_DecodeUTF32 
PyUnicode_DecodeUTF32
inline
           
PyUnicode_DecodeUTF32Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_Decode
inline
           
PyUnicode_DecodeUTF32Stateful will not be inlined into PyUnicode_Decode 
PyUnicode_Decode
5216
}
5217
5218
PyObject *
5219
PyUnicode_DecodeUTF32Stateful(const char *s,
5220
                              Py_ssize_t size,
5221
                              const char *errors,
5222
                              int *byteorder,
5223
                              Py_ssize_t *consumed)
5224
{
5225
    const char *starts = s;
5226
    Py_ssize_t startinpos;
5227
    Py_ssize_t endinpos;
5228
    _PyUnicodeWriter writer;
5229
    const unsigned char *q, *e;
5230
    int le, bo = 0;       /* assume native ordering by default */
5231
    const char *encoding;
5232
    const char *errmsg = "";
5233
    PyObject *errorHandler = NULL;
5234
    PyObject *exc = NULL;
5235
5236
    q = (unsigned char *)s;
5237
    e = q + size;
5238
5239
    if (byteorder)
5240
        bo = *byteorder;
5241
5242
    /* Check for BOM marks (U+FEFF) in the input and adjust current
5243
       byte order setting accordingly. In native mode, the leading BOM
5244
       mark is skipped, in all other modes, it is copied to the output
5245
       stream as-is (giving a ZWNBSP character). */
5246
    if (bo == 0 && size >= 4) {
5247
        Py_UCS4 bom = ((unsigned int)q[3] << 24) | (q[2] << 16) | (q[1] << 8) | q[0];
gvn
                                     
load of type i8* eliminated in favor of  
PyUnicode_DecodeUTF32Stateful
5248
        if (bom == 0x0000FEFF) {
5249
            bo = -1;
5250
            q += 4;
5251
        }
5252
        else if (bom == 0xFFFE0000) {
5253
            bo = 1;
5254
            q += 4;
5255
        }
5256
        if (byteorder)
5257
            *byteorder = bo;
5258
    }
5259
5260
    if (q == e) {
gvn
        
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF32Stateful
gvn
             
load of type i8* eliminated in favor of getelementptr 
PyUnicode_DecodeUTF32Stateful
5261
        if (consumed)
5262
            *consumed = size;
5263
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_DecodeUTF32Stateful
inline
        
PyUnicode_New will not be inlined into PyUnicode_DecodeUTF32Stateful 
PyUnicode_DecodeUTF32Stateful
gvn
        
load of type %struct._object* eliminated in favor of phi 
PyUnicode_DecodeUTF32Stateful
5264
    }
5265
5266
#ifdef WORDS_BIGENDIAN
5267
    le = bo < 0;
5268
#else
5269
    le = bo <= 0;
5270
#endif
5271
    encoding = le ? "utf-32-le" : "utf-32-be";
5272
5273
    _PyUnicodeWriter_Init(&writer);
inline
    
_PyUnicodeWriter_Init can be inlined into PyUnicode_DecodeUTF32Stateful with cost=-30 (threshold=375) 
PyUnicode_DecodeUTF32Stateful
inline
    
_PyUnicodeWriter_Init inlined into PyUnicode_DecodeUTF32Stateful 
PyUnicode_DecodeUTF32Stateful
5274
    writer.min_length = (e - q + 3) / 4;
gvn
                         
load of type i64 eliminated in favor of ptrtoint 
PyUnicode_DecodeUTF32Stateful
gvn
                             
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF32Stateful
5275
    if (_PyUnicodeWriter_Prepare(&writer, writer.min_length, 127) == -1)
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF32Stateful
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeUTF32Stateful 
PyUnicode_DecodeUTF32Stateful
gvn
        
load of type i32 eliminated in favor of 0 
PyUnicode_DecodeUTF32Stateful
5276
        goto onError;
5277
5278
    while (1) {
5279
        Py_UCS4 ch = 0;
5280
        Py_UCS4 maxch = PyUnicode_MAX_CHAR_VALUE(writer.buffer);
licm
                        
hosting bitcast 
PyUnicode_DecodeUTF32Stateful
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
gvn
                        
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
                        
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
                        
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
5281
5282
        if (e - q >= 4) {
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
5283
            enum PyUnicode_Kind kind = writer.kind;
licm
                                              
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
gvn
                                              
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
                                              
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
5284
            void *data = writer.data;
licm
                                
hosting getelementptr 
PyUnicode_DecodeUTF32Stateful
licm
                                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
gvn
                                
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
                                
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
5285
            const unsigned char *last = e - 4;
5286
            Py_ssize_t pos = writer.pos;
licm
                                    
hosting getelementptr 
PyUnicode_DecodeUTF32Stateful
licm
                                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
gvn
                                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
                                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
5287
            if (le) {
5288
                do {
loop-vectorize
                
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeUTF32Stateful
loop-vectorize
                
loop not vectorized 
PyUnicode_DecodeUTF32Stateful
5289
                    ch = ((unsigned int)q[3] << 24) | (q[2] << 16) | (q[1] << 8) | q[0];
licm
                                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
gvn
                                                                                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF32Stateful
5290
                    if (ch > maxch)
5291
                        break;
5292
                    if (kind != PyUnicode_1BYTE_KIND &&
licm
                             
hosting icmp 
PyUnicode_DecodeUTF32Stateful
5293
                        Py_UNICODE_IS_SURROGATE(ch))
5294
                        break;
5295
                    PyUnicode_WRITE(kind, data, pos++, ch);
licm
                    
hosting bitcast 
PyUnicode_DecodeUTF32Stateful
5296
                    q += 4;
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
licm
                      
Moving accesses to memory location out of the loop 
PyUnicode_DecodeUTF32Stateful
5297
                } while (q <= last);
5298
            }
5299
            else {
5300
                do {
loop-vectorize
                
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeUTF32Stateful
loop-vectorize
                
loop not vectorized 
PyUnicode_DecodeUTF32Stateful
5301
                    ch = ((unsigned int)q[0] << 24) | (q[1] << 16) | (q[2] << 8) | q[3];
licm
                                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
gvn
                                        
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF32Stateful
5302
                    if (ch > maxch)
5303
                        break;
5304
                    if (kind != PyUnicode_1BYTE_KIND &&
licm
                             
hosting icmp 
PyUnicode_DecodeUTF32Stateful
5305
                        Py_UNICODE_IS_SURROGATE(ch))
5306
                        break;
5307
                    PyUnicode_WRITE(kind, data, pos++, ch);
licm
                    
hosting bitcast 
PyUnicode_DecodeUTF32Stateful
licm
                    
hosting icmp 
PyUnicode_DecodeUTF32Stateful
5308
                    q += 4;
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
licm
                      
Moving accesses to memory location out of the loop 
PyUnicode_DecodeUTF32Stateful
5309
                } while (q <= last);
5310
            }
5311
            writer.pos = pos;
5312
        }
5313
5314
        if (Py_UNICODE_IS_SURROGATE(ch)) {
5315
            errmsg = "code point in surrogate code point range(0xd800, 0xe000)";
5316
            startinpos = ((const char *)q) - starts;
licm
                                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
licm
                                             
hosting bitcast 
PyUnicode_DecodeUTF32Stateful
licm
                                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
gvn
                                        
load of type i64 eliminated in favor of ptrtoint 
PyUnicode_DecodeUTF32Stateful
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
5317
            endinpos = startinpos + 4;
5318
        }
5319
        else if (ch <= maxch) {
5320
            if (q == e || consumed)
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
licm
                          
hosting icmp 
PyUnicode_DecodeUTF32Stateful
gvn
                
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF32Stateful
gvn
                     
load of type i8* eliminated in favor of load 
PyUnicode_DecodeUTF32Stateful
5321
                break;
5322
            /* remaining bytes at the end? (size should be divisible by 4) */
5323
            errmsg = "truncated data";
5324
            startinpos = ((const char *)q) - starts;
licm
                                             
hosting bitcast 
PyUnicode_DecodeUTF32Stateful
licm
                                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
5325
            endinpos = ((const char *)e) - starts;
5326
        }
5327
        else {
5328
            if (ch < 0x110000) {
5329
                if (_PyUnicodeWriter_WriteCharInline(&writer, ch) < 0)
inline
                    
_PyUnicodeWriter_WriteCharInline can be inlined into PyUnicode_DecodeUTF32Stateful with cost=150 (threshold=325) 
PyUnicode_DecodeUTF32Stateful
inline
                    
_PyUnicodeWriter_WriteCharInline inlined into PyUnicode_DecodeUTF32Stateful 
PyUnicode_DecodeUTF32Stateful
5330
                    goto onError;
5331
                q += 4;
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
gvn
                  
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF32Stateful
5332
                continue;
5333
            }
5334
            errmsg = "code point not in range(0x110000)";
5335
            startinpos = ((const char *)q) - starts;
licm
                                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
licm
                                             
hosting bitcast 
PyUnicode_DecodeUTF32Stateful
licm
                                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
gvn
                                        
load of type i64 eliminated in favor of ptrtoint 
PyUnicode_DecodeUTF32Stateful
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
5336
            endinpos = startinpos + 4;
5337
        }
5338
5339
        /* The remaining input chars are ignored if the callback
5340
           chooses to skip the input */
5341
        if (unicode_decode_call_errorhandler_writer(
inline
            
unicode_decode_call_errorhandler_writer too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF32Stateful
inline
            
unicode_decode_call_errorhandler_writer will not be inlined into PyUnicode_DecodeUTF32Stateful 
PyUnicode_DecodeUTF32Stateful
5342
                errors, &errorHandler,
5343
                encoding, errmsg,
5344
                &starts, (const char **)&e, &startinpos, &endinpos, &exc, (const char **)&q,
5345
                &writer))
5346
            goto onError;
5347
    }
5348
5349
    if (consumed)
5350
        *consumed = (const char *)q-starts;
gvn
                                  
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF32Stateful
gvn
                                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
5351
5352
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
5353
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
5354
    return _PyUnicodeWriter_Finish(&writer);
inline
           
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
PyUnicode_DecodeUTF32Stateful
inline
           
_PyUnicodeWriter_Finish will not be inlined into PyUnicode_DecodeUTF32Stateful 
PyUnicode_DecodeUTF32Stateful
5355
5356
  onError:
5357
    _PyUnicodeWriter_Dealloc(&writer);
inline
    
_PyUnicodeWriter_Dealloc can be inlined into PyUnicode_DecodeUTF32Stateful with cost=20 (threshold=250) 
PyUnicode_DecodeUTF32Stateful
inline
    
_PyUnicodeWriter_Dealloc inlined into PyUnicode_DecodeUTF32Stateful 
PyUnicode_DecodeUTF32Stateful
5358
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
5359
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
5360
    return NULL;
5361
}
5362
5363
PyObject *
5364
_PyUnicode_EncodeUTF32(PyObject *str,
5365
                       const char *errors,
5366
                       int byteorder)
5367
{
5368
    enum PyUnicode_Kind kind;
5369
    const void *data;
5370
    Py_ssize_t len;
5371
    PyObject *v;
5372
    uint32_t *out;
5373
#if PY_LITTLE_ENDIAN
5374
    int native_ordering = byteorder <= 0;
5375
#else
5376
    int native_ordering = byteorder >= 0;
5377
#endif
5378
    const char *encoding;
5379
    Py_ssize_t nsize, pos;
5380
    PyObject *errorHandler = NULL;
5381
    PyObject *exc = NULL;
5382
    PyObject *rep = NULL;
5383
5384
    if (!PyUnicode_Check(str)) {
5385
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into _PyUnicode_EncodeUTF32 because its definition is unavailable 
_PyUnicode_EncodeUTF32
5386
        return NULL;
5387
    }
5388
    if (PyUnicode_READY(str) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeUTF32
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_EncodeUTF32 
_PyUnicode_EncodeUTF32
5389
        return NULL;
5390
    kind = PyUnicode_KIND(str);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
           
load eliminated by PRE 
_PyUnicode_EncodeUTF32
5391
    data = PyUnicode_DATA(str);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
5392
    len = PyUnicode_GET_LENGTH(str);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
5393
5394
    if (len > PY_SSIZE_T_MAX / 4 - (byteorder == 0))
5395
        return PyErr_NoMemory();
inline
               
PyErr_NoMemory will not be inlined into _PyUnicode_EncodeUTF32 because its definition is unavailable 
_PyUnicode_EncodeUTF32
5396
    nsize = len + (byteorder == 0);
5397
    v = PyBytes_FromStringAndSize(NULL, nsize * 4);
inline
        
PyBytes_FromStringAndSize will not be inlined into _PyUnicode_EncodeUTF32 because its definition is unavailable 
_PyUnicode_EncodeUTF32
5398
    if (v == NULL)
5399
        return NULL;
5400
5401
    /* output buffer is 4-bytes aligned */
5402
    assert(_Py_IS_ALIGNED(PyBytes_AS_STRING(v), 4));
5403
    out = (uint32_t *)PyBytes_AS_STRING(v);
5404
    if (byteorder == 0)
5405
        *out++ = 0xFEFF;
5406
    if (len == 0)
5407
        goto done;
5408
5409
    if (byteorder == -1)
5410
        encoding = "utf-32-le";
5411
    else if (byteorder == 1)
5412
        encoding = "utf-32-be";
5413
    else
5414
        encoding = "utf-32";
5415
5416
    if (kind == PyUnicode_1BYTE_KIND) {
5417
        ucs1lib_utf32_encode((const Py_UCS1 *)data, len, &out, native_ordering);
inline
        
ucs1lib_utf32_encode can be inlined into _PyUnicode_EncodeUTF32 with cost=255 (threshold=325) 
_PyUnicode_EncodeUTF32
inline
        
ucs1lib_utf32_encode inlined into _PyUnicode_EncodeUTF32 
_PyUnicode_EncodeUTF32
5418
        goto done;
5419
    }
5420
5421
    pos = 0;
5422
    while (pos < len) {
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeUTF32
gvn
           
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_EncodeUTF32
gvn
           
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
5423
        Py_ssize_t repsize, moreunits;
5424
5425
        if (kind == PyUnicode_2BYTE_KIND) {
licm
                 
hosting icmp 
_PyUnicode_EncodeUTF32
5426
            pos += ucs2lib_utf32_encode((const Py_UCS2 *)data + pos, len - pos,
inline
                   
ucs2lib_utf32_encode can be inlined into _PyUnicode_EncodeUTF32 with cost=-14550 (threshold=325) 
_PyUnicode_EncodeUTF32
inline
                   
ucs2lib_utf32_encode inlined into _PyUnicode_EncodeUTF32 
_PyUnicode_EncodeUTF32
licm
                                        
hosting bitcast 
_PyUnicode_EncodeUTF32
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeUTF32
gvn
                
load of type i64 eliminated in favor of phi 
_PyUnicode_EncodeUTF32
5427
                                        &out, native_ordering);
5428
        }
5429
        else {
5430
            assert(kind == PyUnicode_4BYTE_KIND);
5431
            pos += ucs4lib_utf32_encode((const Py_UCS4 *)data + pos, len - pos,
inline
                   
ucs4lib_utf32_encode can be inlined into _PyUnicode_EncodeUTF32 with cost=-14645 (threshold=325) 
_PyUnicode_EncodeUTF32
inline
                   
ucs4lib_utf32_encode inlined into _PyUnicode_EncodeUTF32 
_PyUnicode_EncodeUTF32
licm
                                        
hosting bitcast 
_PyUnicode_EncodeUTF32
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeUTF32
gvn
                
load of type i64 eliminated in favor of phi 
_PyUnicode_EncodeUTF32
5432
                                        &out, native_ordering);
5433
        }
5434
        if (pos == len)
5435
            break;
5436
5437
        rep = unicode_encode_call_errorhandler(
inline
              
unicode_encode_call_errorhandler too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeUTF32
inline
              
unicode_encode_call_errorhandler will not be inlined into _PyUnicode_EncodeUTF32 
_PyUnicode_EncodeUTF32
5438
                errors, &errorHandler,
5439
                encoding, "surrogates not allowed",
5440
                str, &exc, pos, pos + 1, &pos);
5441
        if (!rep)
5442
            goto error;
5443
5444
        if (PyBytes_Check(rep)) {
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
5445
            repsize = PyBytes_GET_SIZE(rep);
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
5446
            if (repsize & 3) {
5447
                raise_encode_exception(&exc, encoding,
inline
                
raise_encode_exception can be inlined into _PyUnicode_EncodeUTF32 with cost=50 (threshold=250) 
_PyUnicode_EncodeUTF32
inline
                
raise_encode_exception inlined into _PyUnicode_EncodeUTF32 
_PyUnicode_EncodeUTF32
5448
                                       str, pos - 1, pos,
gvn
                                            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
5449
                                       "surrogates not allowed");
5450
                goto error;
5451
            }
5452
            moreunits = repsize / 4;
5453
        }
5454
        else {
5455
            assert(PyUnicode_Check(rep));
5456
            if (PyUnicode_READY(rep) < 0)
inline
                
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeUTF32
inline
                
_PyUnicode_Ready will not be inlined into _PyUnicode_EncodeUTF32 
_PyUnicode_EncodeUTF32
gvn
                
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
5457
                goto error;
5458
            moreunits = repsize = PyUnicode_GET_LENGTH(rep);
gvn
                                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
                                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
5459
            if (!PyUnicode_IS_ASCII(rep)) {
gvn
                 
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
                 
load eliminated by PRE 
_PyUnicode_EncodeUTF32
5460
                raise_encode_exception(&exc, encoding,
inline
                
raise_encode_exception can be inlined into _PyUnicode_EncodeUTF32 with cost=50 (threshold=250) 
_PyUnicode_EncodeUTF32
inline
                
raise_encode_exception inlined into _PyUnicode_EncodeUTF32 
_PyUnicode_EncodeUTF32
5461
                                       str, pos - 1, pos,
gvn
                                            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
                                            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
5462
                                       "surrogates not allowed");
5463
                goto error;
5464
            }
5465
        }
5466
5467
        /* four bytes are reserved for each surrogate */
5468
        if (moreunits > 1) {
5469
            Py_ssize_t outpos = out - (uint32_t*) PyBytes_AS_STRING(v);
licm
                                                  
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeUTF32
gvn
                                                  
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
                                                  
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
5470
            Py_ssize_t morebytes = 4 * (moreunits - 1);
5471
            if (PyBytes_GET_SIZE(v) > PY_SSIZE_T_MAX - morebytes) {
5472
                /* integer overflow */
5473
                PyErr_NoMemory();
inline
                
PyErr_NoMemory will not be inlined into _PyUnicode_EncodeUTF32 because its definition is unavailable 
_PyUnicode_EncodeUTF32
5474
                goto error;
5475
            }
5476
            if (_PyBytes_Resize(&v, PyBytes_GET_SIZE(v) + morebytes) < 0)
inline
                
_PyBytes_Resize will not be inlined into _PyUnicode_EncodeUTF32 because its definition is unavailable 
_PyUnicode_EncodeUTF32
5477
                goto error;
5478
            out = (uint32_t*) PyBytes_AS_STRING(v) + outpos;
licm
                              
hosting bitcast 
_PyUnicode_EncodeUTF32
licm
                              
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeUTF32
gvn
                              
load of type %struct.PyBytesObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
5479
        }
5480
5481
        if (PyBytes_Check(rep)) {
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF32
5482
            memcpy(out, PyBytes_AS_STRING(rep), repsize);
5483
            out += moreunits;
5484
        } else /* rep is unicode */ {
5485
            assert(PyUnicode_KIND(rep) == PyUnicode_1BYTE_KIND);
5486
            ucs1lib_utf32_encode(PyUnicode_1BYTE_DATA(rep), repsize,
inline
            
ucs1lib_utf32_encode can be inlined into _PyUnicode_EncodeUTF32 with cost=-14745 (threshold=325) 
_PyUnicode_EncodeUTF32
inline
            
ucs1lib_utf32_encode inlined into _PyUnicode_EncodeUTF32 
_PyUnicode_EncodeUTF32
gvn
                                 
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
                                 
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
                                 
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
                                 
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
                                 
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
5487
                                 &out, native_ordering);
5488
        }
5489
5490
        Py_CLEAR(rep);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
5491
    }
5492
5493
    /* Cut back to size actually needed. This is necessary for, for example,
5494
       encoding of a string containing isolated surrogates and the 'ignore'
5495
       handler is used. */
5496
    nsize = (unsigned char*) out - (unsigned char*) PyBytes_AS_STRING(v);
gvn
                                                    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
                                                    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
                                                    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
                                                    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
                                                    
load eliminated by PRE 
_PyUnicode_EncodeUTF32
5497
    if (nsize != PyBytes_GET_SIZE(v))
5498
      _PyBytes_Resize(&v, nsize);
inline
      
_PyBytes_Resize will not be inlined into _PyUnicode_EncodeUTF32 because its definition is unavailable 
_PyUnicode_EncodeUTF32
5499
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
5500
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
5501
  done:
5502
    return v;
gvn
           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
5503
  error:
5504
    Py_XDECREF(rep);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_EncodeUTF32
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF32
5505
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
5506
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
5507
    Py_XDECREF(v);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
5508
    return NULL;
5509
}
5510
5511
PyObject *
5512
PyUnicode_EncodeUTF32(const Py_UNICODE *s,
5513
                      Py_ssize_t size,
5514
                      const char *errors,
5515
                      int byteorder)
5516
{
5517
    PyObject *result;
5518
    PyObject *tmp = PyUnicode_FromUnicode(s, size);
inline
                    
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeUTF32
inline
                    
PyUnicode_FromUnicode will not be inlined into PyUnicode_EncodeUTF32 
PyUnicode_EncodeUTF32
5519
    if (tmp == NULL)
5520
        return NULL;
5521
    result = _PyUnicode_EncodeUTF32(tmp, errors, byteorder);
inline
             
_PyUnicode_EncodeUTF32 too costly to inline (cost=650, threshold=625) 
PyUnicode_EncodeUTF32
inline
             
_PyUnicode_EncodeUTF32 will not be inlined into PyUnicode_EncodeUTF32 
PyUnicode_EncodeUTF32
5522
    Py_DECREF(tmp);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeUTF32
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeUTF32
5523
    return result;
5524
}
5525
5526
PyObject *
5527
PyUnicode_AsUTF32String(PyObject *unicode)
5528
{
5529
    return _PyUnicode_EncodeUTF32(unicode, NULL, 0);
inline
           
_PyUnicode_EncodeUTF32 too costly to inline (cost=630, threshold=625) 
PyUnicode_AsUTF32String
inline
           
_PyUnicode_EncodeUTF32 will not be inlined into PyUnicode_AsUTF32String 
PyUnicode_AsUTF32String
5530
}
5531
5532
/* --- UTF-16 Codec ------------------------------------------------------- */
5533
5534
PyObject *
5535
PyUnicode_DecodeUTF16(const char *s,
5536
                      Py_ssize_t size,
5537
                      const char *errors,
5538
                      int *byteorder)
5539
{
5540
    return PyUnicode_DecodeUTF16Stateful(s, size, errors, byteorder, NULL);
inline
           
PyUnicode_DecodeUTF16Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF16
inline
           
PyUnicode_DecodeUTF16Stateful will not be inlined into PyUnicode_DecodeUTF16 
PyUnicode_DecodeUTF16
inline
           
PyUnicode_DecodeUTF16Stateful too costly to inline (cost=630, threshold=625) 
PyUnicode_Decode
inline
           
PyUnicode_DecodeUTF16Stateful will not be inlined into PyUnicode_Decode 
PyUnicode_Decode
5541
}
5542
5543
PyObject *
5544
PyUnicode_DecodeUTF16Stateful(const char *s,
5545
                              Py_ssize_t size,
5546
                              const char *errors,
5547
                              int *byteorder,
5548
                              Py_ssize_t *consumed)
5549
{
5550
    const char *starts = s;
5551
    Py_ssize_t startinpos;
5552
    Py_ssize_t endinpos;
5553
    _PyUnicodeWriter writer;
5554
    const unsigned char *q, *e;
5555
    int bo = 0;       /* assume native ordering by default */
5556
    int native_ordering;
5557
    const char *errmsg = "";
5558
    PyObject *errorHandler = NULL;
5559
    PyObject *exc = NULL;
5560
    const char *encoding;
5561
5562
    q = (unsigned char *)s;
5563
    e = q + size;
5564
5565
    if (byteorder)
5566
        bo = *byteorder;
5567
5568
    /* Check for BOM marks (U+FEFF) in the input and adjust current
5569
       byte order setting accordingly. In native mode, the leading BOM
5570
       mark is skipped, in all other modes, it is copied to the output
5571
       stream as-is (giving a ZWNBSP character). */
5572
    if (bo == 0 && size >= 2) {
5573
        const Py_UCS4 bom = (q[1] << 8) | q[0];
gvn
                             
load of type i8* eliminated in favor of  
PyUnicode_DecodeUTF16Stateful
5574
        if (bom == 0xFEFF) {
5575
            q += 2;
5576
            bo = -1;
5577
        }
5578
        else if (bom == 0xFFFE) {
5579
            q += 2;
5580
            bo = 1;
5581
        }
5582
        if (byteorder)
5583
            *byteorder = bo;
5584
    }
5585
5586
    if (q == e) {
gvn
        
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF16Stateful
gvn
             
load of type i8* eliminated in favor of getelementptr 
PyUnicode_DecodeUTF16Stateful
5587
        if (consumed)
5588
            *consumed = size;
5589
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_DecodeUTF16Stateful
inline
        
PyUnicode_New will not be inlined into PyUnicode_DecodeUTF16Stateful 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type %struct._object* eliminated in favor of phi 
PyUnicode_DecodeUTF16Stateful
5590
    }
5591
5592
#if PY_LITTLE_ENDIAN
5593
    native_ordering = bo <= 0;
5594
    encoding = bo <= 0 ? "utf-16-le" : "utf-16-be";
5595
#else
5596
    native_ordering = bo >= 0;
5597
    encoding = bo >= 0 ? "utf-16-be" : "utf-16-le";
5598
#endif
5599
5600
    /* Note: size will always be longer than the resulting Unicode
5601
       character count */
5602
    _PyUnicodeWriter_Init(&writer);
inline
    
_PyUnicodeWriter_Init can be inlined into PyUnicode_DecodeUTF16Stateful with cost=-30 (threshold=375) 
PyUnicode_DecodeUTF16Stateful
inline
    
_PyUnicodeWriter_Init inlined into PyUnicode_DecodeUTF16Stateful 
PyUnicode_DecodeUTF16Stateful
5603
    writer.min_length = (e - q + 1) / 2;
gvn
                         
load of type i64 eliminated in favor of ptrtoint 
PyUnicode_DecodeUTF16Stateful
gvn
                             
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF16Stateful
5604
    if (_PyUnicodeWriter_Prepare(&writer, writer.min_length, 127) == -1)
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF16Stateful
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeUTF16Stateful 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type i32 eliminated in favor of 0 
PyUnicode_DecodeUTF16Stateful
5605
        goto onError;
5606
5607
    while (1) {
5608
        Py_UCS4 ch = 0;
5609
        if (e - q >= 2) {
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
            
load eliminated by PRE 
PyUnicode_DecodeUTF16Stateful
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
                
load eliminated by PRE 
PyUnicode_DecodeUTF16Stateful
5610
            int kind = writer.kind;
licm
                              
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
gvn
                              
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
                              
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
                              
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
5611
            if (kind == PyUnicode_1BYTE_KIND) {
5612
                if (PyUnicode_IS_ASCII(writer.buffer))
licm
                    
hosting bitcast 
PyUnicode_DecodeUTF16Stateful
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
gvn
                    
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
                    
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
                    
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
                    
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
                    
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
5613
                    ch = asciilib_utf16_decode(&q, e,
inline
                         
asciilib_utf16_decode can be inlined into PyUnicode_DecodeUTF16Stateful with cost=-14540 (threshold=325) 
PyUnicode_DecodeUTF16Stateful
inline
                         
asciilib_utf16_decode inlined into PyUnicode_DecodeUTF16Stateful 
PyUnicode_DecodeUTF16Stateful
5614
                            (Py_UCS1*)writer.data, &writer.pos,
5615
                            native_ordering);
5616
                else
5617
                    ch = ucs1lib_utf16_decode(&q, e,
inline
                         
ucs1lib_utf16_decode can be inlined into PyUnicode_DecodeUTF16Stateful with cost=-14540 (threshold=325) 
PyUnicode_DecodeUTF16Stateful
inline
                         
ucs1lib_utf16_decode inlined into PyUnicode_DecodeUTF16Stateful 
PyUnicode_DecodeUTF16Stateful
5618
                            (Py_UCS1*)writer.data, &writer.pos,
5619
                            native_ordering);
5620
            } else if (kind == PyUnicode_2BYTE_KIND) {
5621
                ch = ucs2lib_utf16_decode(&q, e,
inline
                     
ucs2lib_utf16_decode can be inlined into PyUnicode_DecodeUTF16Stateful with cost=-14535 (threshold=325) 
PyUnicode_DecodeUTF16Stateful
inline
                     
ucs2lib_utf16_decode inlined into PyUnicode_DecodeUTF16Stateful 
PyUnicode_DecodeUTF16Stateful
5622
                        (Py_UCS2*)writer.data, &writer.pos,
licm
                                                       
hosting getelementptr 
PyUnicode_DecodeUTF16Stateful
5623
                        native_ordering);
5624
            } else {
5625
                assert(kind == PyUnicode_4BYTE_KIND);
5626
                ch = ucs4lib_utf16_decode(&q, e,
inline
                     
ucs4lib_utf16_decode can be inlined into PyUnicode_DecodeUTF16Stateful with cost=-14610 (threshold=325) 
PyUnicode_DecodeUTF16Stateful
inline
                     
ucs4lib_utf16_decode inlined into PyUnicode_DecodeUTF16Stateful 
PyUnicode_DecodeUTF16Stateful
5627
                        (Py_UCS4*)writer.data, &writer.pos,
licm
                                                       
hosting getelementptr 
PyUnicode_DecodeUTF16Stateful
5628
                        native_ordering);
5629
            }
5630
        }
5631
5632
        switch (ch)
5633
        {
5634
        case 0:
5635
            /* remaining byte at the end? (size should be even) */
5636
            if (q == e || consumed)
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
licm
                          
hosting icmp 
PyUnicode_DecodeUTF16Stateful
gvn
                
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF16Stateful
gvn
                     
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
                     
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
                     
load eliminated by PRE 
PyUnicode_DecodeUTF16Stateful
5637
                goto End;
5638
            errmsg = "truncated data";
5639
            startinpos = ((const char *)q) - starts;
licm
                                             
hosting bitcast 
PyUnicode_DecodeUTF16Stateful
licm
                                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
5640
            endinpos = ((const char *)e) - starts;
5641
            break;
5642
            /* The remaining input chars are ignored if the callback
5643
               chooses to skip the input */
5644
        case 1:
5645
            q -= 2;
licm
              
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
gvn
              
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF16Stateful
5646
            if (consumed)
licm
                
hosting icmp 
PyUnicode_DecodeUTF16Stateful
5647
                goto End;
5648
            errmsg = "unexpected end of data";
5649
            startinpos = ((const char *)q) - starts;
licm
                                             
hosting bitcast 
PyUnicode_DecodeUTF16Stateful
licm
                                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
5650
            endinpos = ((const char *)e) - starts;
licm
                                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
gvn
                                      
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
                                      
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
5651
            break;
5652
        case 2:
5653
            errmsg = "illegal encoding";
5654
            startinpos = ((const char *)q) - 2 - starts;
licm
                                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
licm
                                                 
hosting bitcast 
PyUnicode_DecodeUTF16Stateful
licm
                                                 
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
gvn
                                        
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF16Stateful
gvn
                                                 
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
                                                 
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
                                                 
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
5655
            endinpos = startinpos + 2;
5656
            break;
5657
        case 3:
5658
            errmsg = "illegal UTF-16 surrogate";
5659
            startinpos = ((const char *)q) - 4 - starts;
licm
                                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
licm
                                                 
hosting bitcast 
PyUnicode_DecodeUTF16Stateful
licm
                                                 
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
gvn
                                        
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeUTF16Stateful
gvn
                                                 
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
                                                 
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
                                                 
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
5660
            endinpos = startinpos + 2;
5661
            break;
5662
        default:
5663
            if (_PyUnicodeWriter_WriteCharInline(&writer, ch) < 0)
inline
                
_PyUnicodeWriter_WriteCharInline can be inlined into PyUnicode_DecodeUTF16Stateful with cost=150 (threshold=325) 
PyUnicode_DecodeUTF16Stateful
inline
                
_PyUnicodeWriter_WriteCharInline inlined into PyUnicode_DecodeUTF16Stateful 
PyUnicode_DecodeUTF16Stateful
5664
                goto onError;
5665
            continue;
5666
        }
5667
5668
        if (unicode_decode_call_errorhandler_writer(
inline
            
unicode_decode_call_errorhandler_writer too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF16Stateful
inline
            
unicode_decode_call_errorhandler_writer will not be inlined into PyUnicode_DecodeUTF16Stateful 
PyUnicode_DecodeUTF16Stateful
5669
                errors,
5670
                &errorHandler,
5671
                encoding, errmsg,
5672
                &starts,
5673
                (const char **)&e,
5674
                &startinpos,
5675
                &endinpos,
5676
                &exc,
5677
                (const char **)&q,
5678
                &writer))
5679
            goto onError;
5680
    }
5681
5682
End:
5683
    if (consumed)
5684
        *consumed = (const char *)q-starts;
gvn
                                  
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF16Stateful
gvn
                                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
                                    
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
                                    
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
5685
5686
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
5687
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
5688
    return _PyUnicodeWriter_Finish(&writer);
inline
           
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
PyUnicode_DecodeUTF16Stateful
inline
           
_PyUnicodeWriter_Finish will not be inlined into PyUnicode_DecodeUTF16Stateful 
PyUnicode_DecodeUTF16Stateful
5689
5690
  onError:
5691
    _PyUnicodeWriter_Dealloc(&writer);
inline
    
_PyUnicodeWriter_Dealloc can be inlined into PyUnicode_DecodeUTF16Stateful with cost=20 (threshold=250) 
PyUnicode_DecodeUTF16Stateful
inline
    
_PyUnicodeWriter_Dealloc inlined into PyUnicode_DecodeUTF16Stateful 
PyUnicode_DecodeUTF16Stateful
5692
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
5693
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
5694
    return NULL;
5695
}
5696
5697
PyObject *
5698
_PyUnicode_EncodeUTF16(PyObject *str,
5699
                       const char *errors,
5700
                       int byteorder)
5701
{
5702
    enum PyUnicode_Kind kind;
5703
    const void *data;
5704
    Py_ssize_t len;
5705
    PyObject *v;
5706
    unsigned short *out;
5707
    Py_ssize_t pairs;
5708
#if PY_BIG_ENDIAN
5709
    int native_ordering = byteorder >= 0;
5710
#else
5711
    int native_ordering = byteorder <= 0;
5712
#endif
5713
    const char *encoding;
5714
    Py_ssize_t nsize, pos;
5715
    PyObject *errorHandler = NULL;
5716
    PyObject *exc = NULL;
5717
    PyObject *rep = NULL;
5718
5719
    if (!PyUnicode_Check(str)) {
5720
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into _PyUnicode_EncodeUTF16 because its definition is unavailable 
_PyUnicode_EncodeUTF16
5721
        return NULL;
5722
    }
5723
    if (PyUnicode_READY(str) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeUTF16
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_EncodeUTF16 
_PyUnicode_EncodeUTF16
5724
        return NULL;
5725
    kind = PyUnicode_KIND(str);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
           
load eliminated by PRE 
_PyUnicode_EncodeUTF16
5726
    data = PyUnicode_DATA(str);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
5727
    len = PyUnicode_GET_LENGTH(str);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
5728
5729
    pairs = 0;
5730
    if (kind == PyUnicode_4BYTE_KIND) {
5731
        const Py_UCS4 *in = (const Py_UCS4 *)data;
5732
        const Py_UCS4 *end = in + len;
5733
        while (in < end) {
5734
            if (*in++ >= 0x10000) {
loop-vectorize
                   
loop not vectorized: could not determine number of loop iterations 
_PyUnicode_EncodeUTF16
loop-vectorize
                   
loop not vectorized 
_PyUnicode_EncodeUTF16
5735
                pairs++;
5736
            }
5737
        }
5738
    }
5739
    if (len > PY_SSIZE_T_MAX / 2 - pairs - (byteorder == 0)) {
5740
        return PyErr_NoMemory();
inline
               
PyErr_NoMemory will not be inlined into _PyUnicode_EncodeUTF16 because its definition is unavailable 
_PyUnicode_EncodeUTF16
5741
    }
5742
    nsize = len + pairs + (byteorder == 0);
5743
    v = PyBytes_FromStringAndSize(NULL, nsize * 2);
inline
        
PyBytes_FromStringAndSize will not be inlined into _PyUnicode_EncodeUTF16 because its definition is unavailable 
_PyUnicode_EncodeUTF16
5744
    if (v == NULL) {
5745
        return NULL;
5746
    }
5747
5748
    /* output buffer is 2-bytes aligned */
5749
    assert(_Py_IS_ALIGNED(PyBytes_AS_STRING(v), 2));
5750
    out = (unsigned short *)PyBytes_AS_STRING(v);
5751
    if (byteorder == 0) {
5752
        *out++ = 0xFEFF;
5753
    }
5754
    if (len == 0) {
5755
        goto done;
5756
    }
5757
5758
    if (kind == PyUnicode_1BYTE_KIND) {
5759
        ucs1lib_utf16_encode((const Py_UCS1 *)data, len, &out, native_ordering);
inline
        
ucs1lib_utf16_encode can be inlined into _PyUnicode_EncodeUTF16 with cost=255 (threshold=325) 
_PyUnicode_EncodeUTF16
inline
        
ucs1lib_utf16_encode inlined into _PyUnicode_EncodeUTF16 
_PyUnicode_EncodeUTF16
5760
        goto done;
5761
    }
5762
5763
    if (byteorder < 0) {
5764
        encoding = "utf-16-le";
5765
    }
5766
    else if (byteorder > 0) {
5767
        encoding = "utf-16-be";
5768
    }
5769
    else {
5770
        encoding = "utf-16";
5771
    }
5772
5773
    pos = 0;
5774
    while (pos < len) {
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeUTF16
gvn
           
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_EncodeUTF16
gvn
           
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
5775
        Py_ssize_t repsize, moreunits;
5776
5777
        if (kind == PyUnicode_2BYTE_KIND) {
licm
                 
hosting icmp 
_PyUnicode_EncodeUTF16
5778
            pos += ucs2lib_utf16_encode((const Py_UCS2 *)data + pos, len - pos,
inline
                   
ucs2lib_utf16_encode can be inlined into _PyUnicode_EncodeUTF16 with cost=-14655 (threshold=325) 
_PyUnicode_EncodeUTF16
inline
                   
ucs2lib_utf16_encode inlined into _PyUnicode_EncodeUTF16 
_PyUnicode_EncodeUTF16
licm
                                        
hosting bitcast 
_PyUnicode_EncodeUTF16
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeUTF16
gvn
                
load of type i64 eliminated in favor of phi 
_PyUnicode_EncodeUTF16
5779
                                        &out, native_ordering);
5780
        }
5781
        else {
5782
            assert(kind == PyUnicode_4BYTE_KIND);
5783
            pos += ucs4lib_utf16_encode((const Py_UCS4 *)data + pos, len - pos,
inline
                   
ucs4lib_utf16_encode can be inlined into _PyUnicode_EncodeUTF16 with cost=-14800 (threshold=325) 
_PyUnicode_EncodeUTF16
inline
                   
ucs4lib_utf16_encode inlined into _PyUnicode_EncodeUTF16 
_PyUnicode_EncodeUTF16
licm
                                        
hosting bitcast 
_PyUnicode_EncodeUTF16
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeUTF16
gvn
                
load of type i64 eliminated in favor of phi 
_PyUnicode_EncodeUTF16
5784
                                        &out, native_ordering);
5785
        }
5786
        if (pos == len)
5787
            break;
5788
5789
        rep = unicode_encode_call_errorhandler(
inline
              
unicode_encode_call_errorhandler too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeUTF16
inline
              
unicode_encode_call_errorhandler will not be inlined into _PyUnicode_EncodeUTF16 
_PyUnicode_EncodeUTF16
5790
                errors, &errorHandler,
5791
                encoding, "surrogates not allowed",
5792
                str, &exc, pos, pos + 1, &pos);
5793
        if (!rep)
5794
            goto error;
5795
5796
        if (PyBytes_Check(rep)) {
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
5797
            repsize = PyBytes_GET_SIZE(rep);
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
5798
            if (repsize & 1) {
5799
                raise_encode_exception(&exc, encoding,
inline
                
raise_encode_exception can be inlined into _PyUnicode_EncodeUTF16 with cost=50 (threshold=250) 
_PyUnicode_EncodeUTF16
inline
                
raise_encode_exception inlined into _PyUnicode_EncodeUTF16 
_PyUnicode_EncodeUTF16
5800
                                       str, pos - 1, pos,
gvn
                                            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
5801
                                       "surrogates not allowed");
5802
                goto error;
5803
            }
5804
            moreunits = repsize / 2;
5805
        }
5806
        else {
5807
            assert(PyUnicode_Check(rep));
5808
            if (PyUnicode_READY(rep) < 0)
inline
                
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeUTF16
inline
                
_PyUnicode_Ready will not be inlined into _PyUnicode_EncodeUTF16 
_PyUnicode_EncodeUTF16
gvn
                
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
5809
                goto error;
5810
            moreunits = repsize = PyUnicode_GET_LENGTH(rep);
gvn
                                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
                                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
5811
            if (!PyUnicode_IS_ASCII(rep)) {
gvn
                 
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
                 
load eliminated by PRE 
_PyUnicode_EncodeUTF16
5812
                raise_encode_exception(&exc, encoding,
inline
                
raise_encode_exception can be inlined into _PyUnicode_EncodeUTF16 with cost=50 (threshold=250) 
_PyUnicode_EncodeUTF16
inline
                
raise_encode_exception inlined into _PyUnicode_EncodeUTF16 
_PyUnicode_EncodeUTF16
5813
                                       str, pos - 1, pos,
gvn
                                            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
                                            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
5814
                                       "surrogates not allowed");
5815
                goto error;
5816
            }
5817
        }
5818
5819
        /* two bytes are reserved for each surrogate */
5820
        if (moreunits > 1) {
5821
            Py_ssize_t outpos = out - (unsigned short*) PyBytes_AS_STRING(v);
licm
                                                        
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeUTF16
gvn
                                                        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
                                                        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
5822
            Py_ssize_t morebytes = 2 * (moreunits - 1);
5823
            if (PyBytes_GET_SIZE(v) > PY_SSIZE_T_MAX - morebytes) {
5824
                /* integer overflow */
5825
                PyErr_NoMemory();
inline
                
PyErr_NoMemory will not be inlined into _PyUnicode_EncodeUTF16 because its definition is unavailable 
_PyUnicode_EncodeUTF16
5826
                goto error;
5827
            }
5828
            if (_PyBytes_Resize(&v, PyBytes_GET_SIZE(v) + morebytes) < 0)
inline
                
_PyBytes_Resize will not be inlined into _PyUnicode_EncodeUTF16 because its definition is unavailable 
_PyUnicode_EncodeUTF16
5829
                goto error;
5830
            out = (unsigned short*) PyBytes_AS_STRING(v) + outpos;
licm
                                    
hosting bitcast 
_PyUnicode_EncodeUTF16
licm
                                    
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeUTF16
gvn
                                    
load of type %struct.PyBytesObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
5831
        }
5832
5833
        if (PyBytes_Check(rep)) {
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF16
5834
            memcpy(out, PyBytes_AS_STRING(rep), repsize);
5835
            out += moreunits;
5836
        } else /* rep is unicode */ {
5837
            assert(PyUnicode_KIND(rep) == PyUnicode_1BYTE_KIND);
5838
            ucs1lib_utf16_encode(PyUnicode_1BYTE_DATA(rep), repsize,
inline
            
ucs1lib_utf16_encode can be inlined into _PyUnicode_EncodeUTF16 with cost=-14745 (threshold=325) 
_PyUnicode_EncodeUTF16
inline
            
ucs1lib_utf16_encode inlined into _PyUnicode_EncodeUTF16 
_PyUnicode_EncodeUTF16
gvn
                                 
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
                                 
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
                                 
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
                                 
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
                                 
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
5839
                                 &out, native_ordering);
5840
        }
5841
5842
        Py_CLEAR(rep);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
5843
    }
5844
5845
    /* Cut back to size actually needed. This is necessary for, for example,
5846
    encoding of a string containing isolated surrogates and the 'ignore' handler
5847
    is used. */
5848
    nsize = (unsigned char*) out - (unsigned char*) PyBytes_AS_STRING(v);
gvn
                                                    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
                                                    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
                                                    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
                                                    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
                                                    
load eliminated by PRE 
_PyUnicode_EncodeUTF16
5849
    if (nsize != PyBytes_GET_SIZE(v))
5850
      _PyBytes_Resize(&v, nsize);
inline
      
_PyBytes_Resize will not be inlined into _PyUnicode_EncodeUTF16 because its definition is unavailable 
_PyUnicode_EncodeUTF16
5851
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
5852
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
5853
  done:
5854
    return v;
gvn
           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
5855
  error:
5856
    Py_XDECREF(rep);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_EncodeUTF16
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeUTF16
5857
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
5858
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
5859
    Py_XDECREF(v);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
5860
    return NULL;
5861
#undef STORECHAR
5862
}
5863
5864
PyObject *
5865
PyUnicode_EncodeUTF16(const Py_UNICODE *s,
5866
                      Py_ssize_t size,
5867
                      const char *errors,
5868
                      int byteorder)
5869
{
5870
    PyObject *result;
5871
    PyObject *tmp = PyUnicode_FromUnicode(s, size);
inline
                    
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeUTF16
inline
                    
PyUnicode_FromUnicode will not be inlined into PyUnicode_EncodeUTF16 
PyUnicode_EncodeUTF16
5872
    if (tmp == NULL)
5873
        return NULL;
5874
    result = _PyUnicode_EncodeUTF16(tmp, errors, byteorder);
inline
             
_PyUnicode_EncodeUTF16 too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeUTF16
inline
             
_PyUnicode_EncodeUTF16 will not be inlined into PyUnicode_EncodeUTF16 
PyUnicode_EncodeUTF16
5875
    Py_DECREF(tmp);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeUTF16
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeUTF16
5876
    return result;
5877
}
5878
5879
PyObject *
5880
PyUnicode_AsUTF16String(PyObject *unicode)
5881
{
5882
    return _PyUnicode_EncodeUTF16(unicode, NULL, 0);
inline
           
_PyUnicode_EncodeUTF16 too costly to inline (cost=630, threshold=625) 
PyUnicode_AsUTF16String
inline
           
_PyUnicode_EncodeUTF16 will not be inlined into PyUnicode_AsUTF16String 
PyUnicode_AsUTF16String
5883
}
5884
5885
/* --- Unicode Escape Codec ----------------------------------------------- */
5886
5887
static _PyUnicode_Name_CAPI *ucnhash_CAPI = NULL;
5888
5889
PyObject *
5890
_PyUnicode_DecodeUnicodeEscape(const char *s,
5891
                               Py_ssize_t size,
5892
                               const char *errors,
5893
                               const char **first_invalid_escape)
5894
{
5895
    const char *starts = s;
5896
    _PyUnicodeWriter writer;
5897
    const char *end;
5898
    PyObject *errorHandler = NULL;
5899
    PyObject *exc = NULL;
5900
5901
    // so we can remember if we've seen an invalid escape char or not
5902
    *first_invalid_escape = NULL;
5903
5904
    if (size == 0) {
5905
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
_PyUnicode_DecodeUnicodeEscape
inline
        
PyUnicode_New will not be inlined into _PyUnicode_DecodeUnicodeEscape 
_PyUnicode_DecodeUnicodeEscape
gvn
        
load of type %struct._object* eliminated in favor of phi 
_PyUnicode_DecodeUnicodeEscape
5906
    }
5907
    /* Escaped strings will always be longer than the resulting
5908
       Unicode string, so we start with size here and then reduce the
5909
       length after conversion to the true value.
5910
       (but if the error callback returns a long replacement string
5911
       we'll have to allocate more space) */
5912
    _PyUnicodeWriter_Init(&writer);
inline
    
_PyUnicodeWriter_Init can be inlined into _PyUnicode_DecodeUnicodeEscape with cost=-30 (threshold=375) 
_PyUnicode_DecodeUnicodeEscape
inline
    
_PyUnicodeWriter_Init inlined into _PyUnicode_DecodeUnicodeEscape 
_PyUnicode_DecodeUnicodeEscape
5913
    writer.min_length = size;
5914
    if (_PyUnicodeWriter_Prepare(&writer, size, 127) < 0) {
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
_PyUnicode_DecodeUnicodeEscape
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into _PyUnicode_DecodeUnicodeEscape 
_PyUnicode_DecodeUnicodeEscape
gvn
        
load of type i32 eliminated in favor of 0 
_PyUnicode_DecodeUnicodeEscape
5915
        goto onError;
5916
    }
5917
5918
    end = s + size;
gvn
          
load of type i8* eliminated in favor of  
_PyUnicode_DecodeUnicodeEscape
5919
    while (s < end) {
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
               
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
gvn
           
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
               
load of type i8* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5920
        unsigned char c = (unsigned char) *s++;
gvn
                                          
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                                          
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
5921
        Py_UCS4 ch;
licm
        
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
5922
        int count;
5923
        Py_ssize_t startinpos;
licm
        
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
5924
        Py_ssize_t endinpos;
licm
        
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
5925
        const char *message;
5926
5927
#define WRITE_ASCII_CHAR(ch)                                                  \
5928
            do {                                                              \
5929
                assert(ch <= 127);                                            \
5930
                assert(writer.pos < writer.size);                             \
5931
                PyUnicode_WRITE(writer.kind, writer.data, writer.pos++, ch);  \
5932
            } while(0)
5933
5934
#define WRITE_CHAR(ch)                                                        \
5935
            do {                                                              \
5936
                if (ch <= writer.maxchar) {                                   \
5937
                    assert(writer.pos < writer.size);                         \
5938
                    PyUnicode_WRITE(writer.kind, writer.data, writer.pos++, ch); \
5939
                }                                                             \
5940
                else if (_PyUnicodeWriter_WriteCharInline(&writer, ch) < 0) { \
5941
                    goto onError;                                             \
5942
                }                                                             \
5943
            } while(0)
5944
5945
        /* Non-escape characters are interpreted as Unicode ordinals */
5946
        if (c != '\\') {
5947
            WRITE_CHAR(c);
inline
            
_PyUnicodeWriter_WriteCharInline can be inlined into _PyUnicode_DecodeUnicodeEscape with cost=150 (threshold=325) 
_PyUnicode_DecodeUnicodeEscape
inline
            
_PyUnicodeWriter_WriteCharInline inlined into _PyUnicode_DecodeUnicodeEscape 
_PyUnicode_DecodeUnicodeEscape
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
            
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
            
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5948
            continue;
5949
        }
5950
5951
        startinpos = s - starts - 1;
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                         
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
gvn
                     
load of type i8* eliminated in favor of getelementptr 
_PyUnicode_DecodeUnicodeEscape
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5952
        /* \ - Escapes */
5953
        if (s >= end) {
5954
            message = "\\ at end of string";
5955
            goto error;
5956
        }
5957
        c = (unsigned char) *s++;
5958
5959
        assert(writer.pos < writer.size);
5960
        switch (c) {
5961
5962
            /* \x escapes */
5963
        case '\n': continue;
5964
        case '\\': WRITE_ASCII_CHAR('\\'); continue;
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                   
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
                   
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5965
        case '\'': WRITE_ASCII_CHAR('\''); continue;
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                   
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
                   
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5966
        case '\"': WRITE_ASCII_CHAR('\"'); continue;
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                   
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
                   
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5967
        case 'b': WRITE_ASCII_CHAR('\b'); continue;
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5968
        /* FF */
5969
        case 'f': WRITE_ASCII_CHAR('\014'); continue;
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5970
        case 't': WRITE_ASCII_CHAR('\t'); continue;
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5971
        case 'n': WRITE_ASCII_CHAR('\n'); continue;
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5972
        case 'r': WRITE_ASCII_CHAR('\r'); continue;
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5973
        /* VT */
5974
        case 'v': WRITE_ASCII_CHAR('\013'); continue;
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5975
        /* BEL, not classic C */
5976
        case 'a': WRITE_ASCII_CHAR('\007'); continue;
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
                  
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                  
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5977
5978
            /* \OOO (octal) escapes */
5979
        case '0': case '1': case '2': case '3':
5980
        case '4': case '5': case '6': case '7':
5981
            ch = c - '0';
5982
            if (s < end && '0' <= *s && *s <= '7') {
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* eliminated in favor of getelementptr 
_PyUnicode_DecodeUnicodeEscape
gvn
                    
load of type i8* eliminated in favor of phi 
_PyUnicode_DecodeUnicodeEscape
gvn
                                  
load of type i8 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
5983
                ch = (ch<<3) + *s++ - '0';
gvn
                               
load of type i8 eliminated in favor of load 
_PyUnicode_DecodeUnicodeEscape
5984
                if (s < end && '0' <= *s && *s <= '7') {
gvn
                                      
load of type i8 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
5985
                    ch = (ch<<3) + *s++ - '0';
gvn
                                   
load of type i8 eliminated in favor of load 
_PyUnicode_DecodeUnicodeEscape
5986
                }
5987
            }
5988
            WRITE_CHAR(ch);
inline
            
_PyUnicodeWriter_WriteCharInline can be inlined into _PyUnicode_DecodeUnicodeEscape with cost=150 (threshold=325) 
_PyUnicode_DecodeUnicodeEscape
inline
            
_PyUnicodeWriter_WriteCharInline inlined into _PyUnicode_DecodeUnicodeEscape 
_PyUnicode_DecodeUnicodeEscape
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
            
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
            
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 eliminated in favor of phi 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
5989
            continue;
5990
5991
            /* hex escapes */
5992
            /* \xXX */
5993
        case 'x':
5994
            count = 2;
5995
            message = "truncated \\xXX escape";
5996
            goto hexescape;
5997
5998
            /* \uXXXX */
5999
        case 'u':
6000
            count = 4;
6001
            message = "truncated \\uXXXX escape";
6002
            goto hexescape;
6003
6004
            /* \UXXXXXXXX */
6005
        case 'U':
6006
            count = 8;
6007
            message = "truncated \\UXXXXXXXX escape";
6008
        hexescape:
6009
            for (ch = 0; count && s < end; ++s, --count) {
licm
                                  
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                                      
hosting load 
_PyUnicode_DecodeUnicodeEscape
licm
                                           
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                                           
Moving accesses to memory location out of the loop 
_PyUnicode_DecodeUnicodeEscape
gvn
                                           
load of type i8* eliminated in favor of getelementptr 
_PyUnicode_DecodeUnicodeEscape
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_DecodeUnicodeEscape
loop-vectorize
            
loop not vectorized 
_PyUnicode_DecodeUnicodeEscape
6010
                c = (unsigned char)*s;
gvn
                                   
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                   
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                   
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                   
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
6011
                ch <<= 4;
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i32 eliminated in favor of phi 
_PyUnicode_DecodeUnicodeEscape
6012
                if (c >= '0' && c <= '9') {
6013
                    ch += c - '0';
6014
                }
6015
                else if (c >= 'a' && c <= 'f') {
6016
                    ch += c - ('a' - 10);
6017
                }
6018
                else if (c >= 'A' && c <= 'F') {
6019
                    ch += c - ('A' - 10);
6020
                }
6021
                else {
6022
                    break;
6023
                }
6024
            }
6025
            if (count) {
6026
                goto error;
6027
            }
6028
6029
            /* when we get here, ch is a 32-bit unicode character */
6030
            if (ch > MAX_UNICODE) {
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i32 eliminated in favor of phi 
_PyUnicode_DecodeUnicodeEscape
6031
                message = "illegal Unicode character";
6032
                goto error;
6033
            }
6034
6035
            WRITE_CHAR(ch);
inline
            
_PyUnicodeWriter_WriteCharInline can be inlined into _PyUnicode_DecodeUnicodeEscape with cost=150 (threshold=325) 
_PyUnicode_DecodeUnicodeEscape
inline
            
_PyUnicodeWriter_WriteCharInline inlined into _PyUnicode_DecodeUnicodeEscape 
_PyUnicode_DecodeUnicodeEscape
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
            
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
            
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
6036
            continue;
6037
6038
            /* \N{name} */
6039
        case 'N':
6040
            if (ucnhash_CAPI == NULL) {
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type %struct._PyUnicode_Name_CAPI* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
6041
                /* load the unicode data module */
6042
                ucnhash_CAPI = (_PyUnicode_Name_CAPI *)PyCapsule_Import(
inline
                                                       
PyCapsule_Import will not be inlined into _PyUnicode_DecodeUnicodeEscape because its definition is unavailable 
_PyUnicode_DecodeUnicodeEscape
6043
                                                PyUnicodeData_CAPSULE_NAME, 1);
6044
                if (ucnhash_CAPI == NULL) {
6045
                    PyErr_SetString(
inline
                    
PyErr_SetString will not be inlined into _PyUnicode_DecodeUnicodeEscape because its definition is unavailable 
_PyUnicode_DecodeUnicodeEscape
6046
                        PyExc_UnicodeError,
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
6047
                        "\\N escapes not supported (can't load unicodedata module)"
6048
                        );
6049
                    goto onError;
6050
                }
6051
            }
6052
6053
            message = "malformed \\N character escape";
6054
            if (*s == '{') {
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
gvn
                 
load of type i8* eliminated in favor of getelementptr 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
6055
                const char *start = ++s;
6056
                size_t namelen;
6057
                /* look for the closing brace */
6058
                while (s < end && *s != '}')
licm
                           
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
gvn
                           
load of type i8* eliminated in favor of phi 
_PyUnicode_DecodeUnicodeEscape
gvn
                                  
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                  
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
loop-vectorize
                
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_DecodeUnicodeEscape
loop-vectorize
                
loop not vectorized 
_PyUnicode_DecodeUnicodeEscape
6059
                    s++;
6060
                namelen = s - start;
6061
                if (namelen && s < end) {
6062
                    /* found a name.  look it up in the unicode database */
6063
                    s++;
6064
                    ch = 0xffffffff; /* in case 'getcode' messes up */
6065
                    if (namelen <= INT_MAX &&
6066
                        ucnhash_CAPI->getcode(NULL, start, (int)namelen,
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
gvn
                        
load of type %struct._PyUnicode_Name_CAPI* eliminated in favor of phi 
_PyUnicode_DecodeUnicodeEscape
6067
                                              &ch, 0)) {
6068
                        assert(ch <= MAX_UNICODE);
6069
                        WRITE_CHAR(ch);
inline
                        
_PyUnicodeWriter_WriteCharInline can be inlined into _PyUnicode_DecodeUnicodeEscape with cost=150 (threshold=325) 
_PyUnicode_DecodeUnicodeEscape
inline
                        
_PyUnicodeWriter_WriteCharInline inlined into _PyUnicode_DecodeUnicodeEscape 
_PyUnicode_DecodeUnicodeEscape
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                        
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
                        
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                        
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                        
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
6070
                        continue;
6071
                    }
6072
                    message = "unknown Unicode character name";
6073
                }
6074
            }
6075
            goto error;
6076
6077
        default:
6078
            if (*first_invalid_escape == NULL) {
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                
load of type i8* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
6079
                *first_invalid_escape = s-1; /* Back up one char, since we've
6080
                                                already incremented s. */
6081
            }
6082
            WRITE_ASCII_CHAR('\\');
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
            
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
            
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
6083
            WRITE_CHAR(c);
inline
            
_PyUnicodeWriter_WriteCharInline can be inlined into _PyUnicode_DecodeUnicodeEscape with cost=150 (threshold=325) 
_PyUnicode_DecodeUnicodeEscape
inline
            
_PyUnicodeWriter_WriteCharInline inlined into _PyUnicode_DecodeUnicodeEscape 
_PyUnicode_DecodeUnicodeEscape
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
            
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
            
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
6084
            continue;
6085
        }
6086
6087
      error:
6088
        endinpos = s-starts;
licm
                   
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
gvn
                   
load of type i64 eliminated in favor of phi 
_PyUnicode_DecodeUnicodeEscape
gvn
                     
load of type i64 eliminated in favor of load 
_PyUnicode_DecodeUnicodeEscape
6089
        writer.min_length = end - s + writer.pos;
licm
                            
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
licm
                            
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
                                             
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
                                             
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
gvn
                            
load of type i64 eliminated in favor of phi 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
6090
        if (unicode_decode_call_errorhandler_writer(
inline
            
unicode_decode_call_errorhandler_writer too costly to inline (cost=630, threshold=625) 
_PyUnicode_DecodeUnicodeEscape
inline
            
unicode_decode_call_errorhandler_writer will not be inlined into _PyUnicode_DecodeUnicodeEscape 
_PyUnicode_DecodeUnicodeEscape
6091
                errors, &errorHandler,
6092
                "unicodeescape", message,
6093
                &starts, &end, &startinpos, &endinpos, &exc, &s,
6094
                &writer)) {
6095
            goto onError;
6096
        }
6097
        if (_PyUnicodeWriter_Prepare(&writer, writer.min_length, 127) < 0) {
inline
            
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
_PyUnicode_DecodeUnicodeEscape
inline
            
_PyUnicodeWriter_PrepareInternal will not be inlined into _PyUnicode_DecodeUnicodeEscape 
_PyUnicode_DecodeUnicodeEscape
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
            
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
            
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
6098
            goto onError;
6099
        }
6100
6101
#undef WRITE_ASCII_CHAR
6102
#undef WRITE_CHAR
6103
    }
6104
6105
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load eliminated by PRE 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
6106
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
6107
    return _PyUnicodeWriter_Finish(&writer);
inline
           
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
_PyUnicode_DecodeUnicodeEscape
inline
           
_PyUnicodeWriter_Finish will not be inlined into _PyUnicode_DecodeUnicodeEscape 
_PyUnicode_DecodeUnicodeEscape
6108
6109
  onError:
6110
    _PyUnicodeWriter_Dealloc(&writer);
inline
    
_PyUnicodeWriter_Dealloc can be inlined into _PyUnicode_DecodeUnicodeEscape with cost=20 (threshold=250) 
_PyUnicode_DecodeUnicodeEscape
inline
    
_PyUnicodeWriter_Dealloc inlined into _PyUnicode_DecodeUnicodeEscape 
_PyUnicode_DecodeUnicodeEscape
6111
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
6112
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
6113
    return NULL;
6114
}
6115
6116
PyObject *
6117
PyUnicode_DecodeUnicodeEscape(const char *s,
6118
                              Py_ssize_t size,
6119
                              const char *errors)
6120
{
6121
    const char *first_invalid_escape;
6122
    PyObject *result = _PyUnicode_DecodeUnicodeEscape(s, size, errors,
inline
                       
_PyUnicode_DecodeUnicodeEscape too costly to inline (cost=655, threshold=625) 
PyUnicode_DecodeUnicodeEscape
inline
                       
_PyUnicode_DecodeUnicodeEscape will not be inlined into PyUnicode_DecodeUnicodeEscape 
PyUnicode_DecodeUnicodeEscape
6123
                                                      &first_invalid_escape);
6124
    if (result == NULL)
6125
        return NULL;
6126
    if (first_invalid_escape != NULL) {
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeUnicodeEscape
6127
        if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
inline
            
PyErr_WarnFormat will not be inlined into PyUnicode_DecodeUnicodeEscape because its definition is unavailable 
PyUnicode_DecodeUnicodeEscape
gvn
                             
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUnicodeEscape
6128
                             "invalid escape sequence '\\%c'",
6129
                             *first_invalid_escape) < 0) {
6130
            Py_DECREF(result);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUnicodeEscape
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_DecodeUnicodeEscape
6131
            return NULL;
6132
        }
6133
    }
6134
    return result;
6135
}
6136
6137
/* Return a Unicode-Escape string version of the Unicode object. */
6138
6139
PyObject *
6140
PyUnicode_AsUnicodeEscapeString(PyObject *unicode)
6141
{
6142
    Py_ssize_t i, len;
6143
    PyObject *repr;
6144
    char *p;
6145
    enum PyUnicode_Kind kind;
6146
    void *data;
6147
    Py_ssize_t expandsize;
6148
6149
    /* Initial allocation is based on the longest-possible character
6150
       escape.
6151
6152
       For UCS1 strings it's '\xxx', 4 bytes per source character.
6153
       For UCS2 strings it's '\uxxxx', 6 bytes per source character.
6154
       For UCS4 strings it's '\U00xxxxxx', 10 bytes per source character.
6155
    */
6156
6157
    if (!PyUnicode_Check(unicode)) {
6158
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_AsUnicodeEscapeString because its definition is unavailable 
PyUnicode_AsUnicodeEscapeString
6159
        return NULL;
6160
    }
6161
    if (PyUnicode_READY(unicode) == -1) {
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_AsUnicodeEscapeString
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_AsUnicodeEscapeString 
PyUnicode_AsUnicodeEscapeString
6162
        return NULL;
6163
    }
6164
6165
    len = PyUnicode_GET_LENGTH(unicode);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsUnicodeEscapeString
6166
    if (len == 0) {
6167
        return PyBytes_FromStringAndSize(NULL, 0);
inline
               
PyBytes_FromStringAndSize will not be inlined into PyUnicode_AsUnicodeEscapeString because its definition is unavailable 
PyUnicode_AsUnicodeEscapeString
6168
    }
6169
6170
    kind = PyUnicode_KIND(unicode);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsUnicodeEscapeString
6171
    data = PyUnicode_DATA(unicode);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_AsUnicodeEscapeString
6172
    /* 4 byte characters can take up 10 bytes, 2 byte characters can take up 6
6173
       bytes, and 1 byte characters 4. */
6174
    expandsize = kind * 2 + 2;
6175
    if (len > PY_SSIZE_T_MAX / expandsize) {
6176
        return PyErr_NoMemory();
inline
               
PyErr_NoMemory will not be inlined into PyUnicode_AsUnicodeEscapeString because its definition is unavailable 
PyUnicode_AsUnicodeEscapeString
6177
    }
6178
    repr = PyBytes_FromStringAndSize(NULL, expandsize * len);
inline
           
PyBytes_FromStringAndSize will not be inlined into PyUnicode_AsUnicodeEscapeString because its definition is unavailable 
PyUnicode_AsUnicodeEscapeString
6179
    if (repr == NULL) {
6180
        return NULL;
6181
    }
6182
6183
    p = PyBytes_AS_STRING(repr);
6184
    for (i = 0; i < len; i++) {
loop-vectorize
    
loop not vectorized 
PyUnicode_AsUnicodeEscapeString
6185
        Py_UCS4 ch = PyUnicode_READ(kind, data, i);
licm
                     
hosting trunc 
PyUnicode_AsUnicodeEscapeString
licm
                     
hosting bitcast 
PyUnicode_AsUnicodeEscapeString
gvn
                     
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_AsUnicodeEscapeString
gvn
                     
load of type i16 not eliminated because it is clobbered by call 
PyUnicode_AsUnicodeEscapeString
gvn
                     
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
licm
                     
hosting icmp 
PyUnicode_AsUnicodeEscapeString
loop-vectorize
                     
loop not vectorized: control flow cannot be substituted for a select 
PyUnicode_AsUnicodeEscapeString
6186
6187
        /* U+0000-U+00ff range */
6188
        if (ch < 0x100) {
6189
            if (ch >= ' ' && ch < 127) {
6190
                if (ch != '\\') {
6191
                    /* Copy printable US ASCII as-is */
6192
                    *p++ = (char) ch;
6193
                }
6194
                /* Escape backslashes */
6195
                else {
6196
                    *p++ = '\\';
6197
                    *p++ = '\\';
6198
                }
6199
            }
6200
6201
            /* Map special whitespace to '\t', \n', '\r' */
6202
            else if (ch == '\t') {
loop-vectorize
                     
loop not vectorized: loop contains a switch statement 
PyUnicode_AsUnicodeEscapeString
6203
                *p++ = '\\';
6204
                *p++ = 't';
6205
            }
6206
            else if (ch == '\n') {
6207
                *p++ = '\\';
6208
                *p++ = 'n';
6209
            }
6210
            else if (ch == '\r') {
6211
                *p++ = '\\';
6212
                *p++ = 'r';
6213
            }
6214
6215
            /* Map non-printable US ASCII and 8-bit characters to '\xHH' */
6216
            else {
6217
                *p++ = '\\';
6218
                *p++ = 'x';
6219
                *p++ = Py_hexdigits[(ch >> 4) & 0x000F];
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsUnicodeEscapeString
gvn
                       
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                       
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
6220
                *p++ = Py_hexdigits[ch & 0x000F];
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsUnicodeEscapeString
gvn
                       
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                       
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
6221
            }
6222
        }
6223
        /* U+0100-U+ffff range: Map 16-bit characters to '\uHHHH' */
6224
        else if (ch < 0x10000) {
6225
            *p++ = '\\';
6226
            *p++ = 'u';
6227
            *p++ = Py_hexdigits[(ch >> 12) & 0x000F];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
6228
            *p++ = Py_hexdigits[(ch >> 8) & 0x000F];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
6229
            *p++ = Py_hexdigits[(ch >> 4) & 0x000F];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
6230
            *p++ = Py_hexdigits[ch & 0x000F];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
6231
        }
6232
        /* U+010000-U+10ffff range: Map 21-bit characters to '\U00HHHHHH' */
6233
        else {
6234
6235
            /* Make sure that the first two digits are zero */
6236
            assert(ch <= MAX_UNICODE && MAX_UNICODE <= 0x10ffff);
6237
            *p++ = '\\';
6238
            *p++ = 'U';
6239
            *p++ = '0';
6240
            *p++ = '0';
6241
            *p++ = Py_hexdigits[(ch >> 20) & 0x0000000F];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
6242
            *p++ = Py_hexdigits[(ch >> 16) & 0x0000000F];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
6243
            *p++ = Py_hexdigits[(ch >> 12) & 0x0000000F];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
6244
            *p++ = Py_hexdigits[(ch >> 8) & 0x0000000F];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
6245
            *p++ = Py_hexdigits[(ch >> 4) & 0x0000000F];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
6246
            *p++ = Py_hexdigits[ch & 0x0000000F];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
6247
        }
6248
    }
6249
6250
    assert(p - PyBytes_AS_STRING(repr) > 0);
6251
    if (_PyBytes_Resize(&repr, p - PyBytes_AS_STRING(repr)) < 0) {
inline
        
_PyBytes_Resize will not be inlined into PyUnicode_AsUnicodeEscapeString because its definition is unavailable 
PyUnicode_AsUnicodeEscapeString
gvn
                                   
load of type %struct.PyBytesObject* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                                   
load of type %struct.PyBytesObject* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                                   
load of type %struct.PyBytesObject* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                                   
load of type %struct.PyBytesObject* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                                   
load of type %struct.PyBytesObject* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                                   
load of type %struct.PyBytesObject* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                                   
load of type %struct.PyBytesObject* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
gvn
                                   
load of type %struct.PyBytesObject* not eliminated because it is clobbered by store 
PyUnicode_AsUnicodeEscapeString
6252
        return NULL;
6253
    }
6254
    return repr;
gvn
           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_AsUnicodeEscapeString
6255
}
6256
6257
PyObject *
6258
PyUnicode_EncodeUnicodeEscape(const Py_UNICODE *s,
6259
                              Py_ssize_t size)
6260
{
6261
    PyObject *result;
6262
    PyObject *tmp = PyUnicode_FromUnicode(s, size);
inline
                    
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeUnicodeEscape
inline
                    
PyUnicode_FromUnicode will not be inlined into PyUnicode_EncodeUnicodeEscape 
PyUnicode_EncodeUnicodeEscape
6263
    if (tmp == NULL) {
6264
        return NULL;
6265
    }
6266
6267
    result = PyUnicode_AsUnicodeEscapeString(tmp);
inline
             
PyUnicode_AsUnicodeEscapeString too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeUnicodeEscape
inline
             
PyUnicode_AsUnicodeEscapeString will not be inlined into PyUnicode_EncodeUnicodeEscape 
PyUnicode_EncodeUnicodeEscape
6268
    Py_DECREF(tmp);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeUnicodeEscape
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeUnicodeEscape
6269
    return result;
6270
}
6271
6272
/* --- Raw Unicode Escape Codec ------------------------------------------- */
6273
6274
PyObject *
6275
PyUnicode_DecodeRawUnicodeEscape(const char *s,
6276
                                 Py_ssize_t size,
6277
                                 const char *errors)
6278
{
6279
    const char *starts = s;
6280
    _PyUnicodeWriter writer;
6281
    const char *end;
6282
    PyObject *errorHandler = NULL;
6283
    PyObject *exc = NULL;
6284
6285
    if (size == 0) {
6286
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_DecodeRawUnicodeEscape
inline
        
PyUnicode_New will not be inlined into PyUnicode_DecodeRawUnicodeEscape 
PyUnicode_DecodeRawUnicodeEscape
gvn
        
load of type %struct._object* eliminated in favor of phi 
PyUnicode_DecodeRawUnicodeEscape
6287
    }
6288
6289
    /* Escaped strings will always be longer than the resulting
6290
       Unicode string, so we start with size here and then reduce the
6291
       length after conversion to the true value. (But decoding error
6292
       handler might have to resize the string) */
6293
    _PyUnicodeWriter_Init(&writer);
inline
    
_PyUnicodeWriter_Init can be inlined into PyUnicode_DecodeRawUnicodeEscape with cost=-30 (threshold=375) 
PyUnicode_DecodeRawUnicodeEscape
inline
    
_PyUnicodeWriter_Init inlined into PyUnicode_DecodeRawUnicodeEscape 
PyUnicode_DecodeRawUnicodeEscape
6294
     writer.min_length = size;
6295
    if (_PyUnicodeWriter_Prepare(&writer, size, 127) < 0) {
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeRawUnicodeEscape
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeRawUnicodeEscape 
PyUnicode_DecodeRawUnicodeEscape
gvn
        
load of type i32 eliminated in favor of 0 
PyUnicode_DecodeRawUnicodeEscape
6296
        goto onError;
6297
    }
6298
6299
    end = s + size;
gvn
          
load of type i8* eliminated in favor of  
PyUnicode_DecodeRawUnicodeEscape
6300
    while (s < end) {
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
licm
               
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
               
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
6301
        unsigned char c = (unsigned char) *s++;
gvn
                                          
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
6302
        Py_UCS4 ch;
6303
        int count;
6304
        Py_ssize_t startinpos;
licm
        
hosting bitcast 
PyUnicode_DecodeRawUnicodeEscape
6305
        Py_ssize_t endinpos;
licm
        
hosting bitcast 
PyUnicode_DecodeRawUnicodeEscape
6306
        const char *message;
6307
6308
#define WRITE_CHAR(ch)                                                        \
6309
            do {                                                              \
6310
                if (ch <= writer.maxchar) {                                   \
6311
                    assert(writer.pos < writer.size);                         \
6312
                    PyUnicode_WRITE(writer.kind, writer.data, writer.pos++, ch); \
6313
                }                                                             \
6314
                else if (_PyUnicodeWriter_WriteCharInline(&writer, ch) < 0) { \
6315
                    goto onError;                                             \
6316
                }                                                             \
6317
            } while(0)
6318
6319
        /* Non-escape characters are interpreted as Unicode ordinals */
6320
        if (c != '\\' || s >= end) {
licm
                         
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
gvn
                         
load of type i8* eliminated in favor of getelementptr 
PyUnicode_DecodeRawUnicodeEscape
6321
            WRITE_CHAR(c);
inline
            
_PyUnicodeWriter_WriteCharInline can be inlined into PyUnicode_DecodeRawUnicodeEscape with cost=150 (threshold=325) 
PyUnicode_DecodeRawUnicodeEscape
inline
            
_PyUnicodeWriter_WriteCharInline inlined into PyUnicode_DecodeRawUnicodeEscape 
PyUnicode_DecodeRawUnicodeEscape
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
licm
            
hosting getelementptr 
PyUnicode_DecodeRawUnicodeEscape
licm
            
hosting bitcast 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
6322
            continue;
6323
        }
6324
6325
        c = (unsigned char) *s++;
6326
        if (c == 'u') {
6327
            count = 4;
6328
            message = "truncated \\uXXXX escape";
6329
        }
6330
        else if (c == 'U') {
6331
            count = 8;
6332
            message = "truncated \\UXXXXXXXX escape";
6333
        }
6334
        else {
6335
            assert(writer.pos < writer.size);
6336
            PyUnicode_WRITE(writer.kind, writer.data, writer.pos++, '\\');
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
licm
            
hosting getelementptr 
PyUnicode_DecodeRawUnicodeEscape
licm
            
hosting bitcast 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
6337
            WRITE_CHAR(c);
inline
            
_PyUnicodeWriter_WriteCharInline can be inlined into PyUnicode_DecodeRawUnicodeEscape with cost=150 (threshold=325) 
PyUnicode_DecodeRawUnicodeEscape
inline
            
_PyUnicodeWriter_WriteCharInline inlined into PyUnicode_DecodeRawUnicodeEscape 
PyUnicode_DecodeRawUnicodeEscape
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
licm
            
hosting getelementptr 
PyUnicode_DecodeRawUnicodeEscape
licm
            
hosting bitcast 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
6338
            continue;
6339
        }
6340
        startinpos = s - starts - 2;
licm
                     
hosting bitcast 
PyUnicode_DecodeRawUnicodeEscape
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
licm
                         
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
gvn
                     
load of type i64 eliminated in favor of ptrtoint 
PyUnicode_DecodeRawUnicodeEscape
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
6341
6342
        /* \uHHHH with 4 hex digits, \U00HHHHHH with 8 */
6343
        for (ch = 0; count && s < end; ++s, --count) {
licm
                              
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
licm
                                  
hosting load 
PyUnicode_DecodeRawUnicodeEscape
licm
                                       
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
licm
                                       
Moving accesses to memory location out of the loop 
PyUnicode_DecodeRawUnicodeEscape
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeRawUnicodeEscape
loop-vectorize
        
loop not vectorized 
PyUnicode_DecodeRawUnicodeEscape
6344
            c = (unsigned char)*s;
6345
            ch <<= 4;
6346
            if (c >= '0' && c <= '9') {
6347
                ch += c - '0';
6348
            }
6349
            else if (c >= 'a' && c <= 'f') {
6350
                ch += c - ('a' - 10);
6351
            }
6352
            else if (c >= 'A' && c <= 'F') {
6353
                ch += c - ('A' - 10);
6354
            }
6355
            else {
6356
                break;
6357
            }
6358
        }
6359
        if (!count) {
6360
            if (ch <= MAX_UNICODE) {
6361
                WRITE_CHAR(ch);
inline
                
_PyUnicodeWriter_WriteCharInline can be inlined into PyUnicode_DecodeRawUnicodeEscape with cost=150 (threshold=325) 
PyUnicode_DecodeRawUnicodeEscape
inline
                
_PyUnicodeWriter_WriteCharInline inlined into PyUnicode_DecodeRawUnicodeEscape 
PyUnicode_DecodeRawUnicodeEscape
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
licm
                
hosting getelementptr 
PyUnicode_DecodeRawUnicodeEscape
licm
                
hosting bitcast 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
6362
                continue;
6363
            }
6364
            message = "\\Uxxxxxxxx out of range";
6365
        }
6366
6367
        endinpos = s-starts;
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
gvn
                   
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeRawUnicodeEscape
gvn
                     
load of type i64 eliminated in favor of load 
PyUnicode_DecodeRawUnicodeEscape
6368
        writer.min_length = end - s + writer.pos;
licm
                            
hosting bitcast 
PyUnicode_DecodeRawUnicodeEscape
licm
                            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
licm
                                             
hosting getelementptr 
PyUnicode_DecodeRawUnicodeEscape
licm
                                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
gvn
                            
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeRawUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeRawUnicodeEscape
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
6369
        if (unicode_decode_call_errorhandler_writer(
inline
            
unicode_decode_call_errorhandler_writer too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeRawUnicodeEscape
inline
            
unicode_decode_call_errorhandler_writer will not be inlined into PyUnicode_DecodeRawUnicodeEscape 
PyUnicode_DecodeRawUnicodeEscape
6370
                errors, &errorHandler,
6371
                "rawunicodeescape", message,
6372
                &starts, &end, &startinpos, &endinpos, &exc, &s,
6373
                &writer)) {
6374
            goto onError;
6375
        }
6376
        if (_PyUnicodeWriter_Prepare(&writer, writer.min_length, 127) < 0) {
inline
            
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeRawUnicodeEscape
inline
            
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeRawUnicodeEscape 
PyUnicode_DecodeRawUnicodeEscape
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
licm
            
hosting getelementptr 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
            
load of type i64 not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
6377
            goto onError;
6378
        }
6379
6380
#undef WRITE_CHAR
6381
    }
6382
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
    
load eliminated by PRE 
PyUnicode_DecodeRawUnicodeEscape
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
6383
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
6384
    return _PyUnicodeWriter_Finish(&writer);
inline
           
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
PyUnicode_DecodeRawUnicodeEscape
inline
           
_PyUnicodeWriter_Finish will not be inlined into PyUnicode_DecodeRawUnicodeEscape 
PyUnicode_DecodeRawUnicodeEscape
6385
6386
  onError:
6387
    _PyUnicodeWriter_Dealloc(&writer);
inline
    
_PyUnicodeWriter_Dealloc can be inlined into PyUnicode_DecodeRawUnicodeEscape with cost=20 (threshold=250) 
PyUnicode_DecodeRawUnicodeEscape
inline
    
_PyUnicodeWriter_Dealloc inlined into PyUnicode_DecodeRawUnicodeEscape 
PyUnicode_DecodeRawUnicodeEscape
6388
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
6389
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
6390
    return NULL;
6391
6392
}
6393
6394
6395
PyObject *
6396
PyUnicode_AsRawUnicodeEscapeString(PyObject *unicode)
6397
{
6398
    PyObject *repr;
6399
    char *p;
6400
    Py_ssize_t expandsize, pos;
6401
    int kind;
6402
    void *data;
6403
    Py_ssize_t len;
6404
6405
    if (!PyUnicode_Check(unicode)) {
6406
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_AsRawUnicodeEscapeString because its definition is unavailable 
PyUnicode_AsRawUnicodeEscapeString
6407
        return NULL;
6408
    }
6409
    if (PyUnicode_READY(unicode) == -1) {
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_AsRawUnicodeEscapeString
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_AsRawUnicodeEscapeString 
PyUnicode_AsRawUnicodeEscapeString
6410
        return NULL;
6411
    }
6412
    kind = PyUnicode_KIND(unicode);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_AsRawUnicodeEscapeString
gvn
           
load eliminated by PRE 
PyUnicode_AsRawUnicodeEscapeString
6413
    data = PyUnicode_DATA(unicode);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_AsRawUnicodeEscapeString
6414
    len = PyUnicode_GET_LENGTH(unicode);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsRawUnicodeEscapeString
6415
    if (kind == PyUnicode_1BYTE_KIND) {
6416
        return PyBytes_FromStringAndSize(data, len);
inline
               
PyBytes_FromStringAndSize will not be inlined into PyUnicode_AsRawUnicodeEscapeString because its definition is unavailable 
PyUnicode_AsRawUnicodeEscapeString
6417
    }
6418
6419
    /* 4 byte characters can take up 10 bytes, 2 byte characters can take up 6
6420
       bytes, and 1 byte characters 4. */
6421
    expandsize = kind * 2 + 2;
6422
6423
    if (len > PY_SSIZE_T_MAX / expandsize) {
6424
        return PyErr_NoMemory();
inline
               
PyErr_NoMemory will not be inlined into PyUnicode_AsRawUnicodeEscapeString because its definition is unavailable 
PyUnicode_AsRawUnicodeEscapeString
6425
    }
6426
    repr = PyBytes_FromStringAndSize(NULL, expandsize * len);
inline
           
PyBytes_FromStringAndSize will not be inlined into PyUnicode_AsRawUnicodeEscapeString because its definition is unavailable 
PyUnicode_AsRawUnicodeEscapeString
6427
    if (repr == NULL) {
6428
        return NULL;
6429
    }
6430
    if (len == 0) {
6431
        return repr;
6432
    }
6433
6434
    p = PyBytes_AS_STRING(repr);
6435
    for (pos = 0; pos < len; pos++) {
loop-vectorize
    
loop not vectorized 
PyUnicode_AsRawUnicodeEscapeString
6436
        Py_UCS4 ch = PyUnicode_READ(kind, data, pos);
licm
                     
hosting icmp 
PyUnicode_AsRawUnicodeEscapeString
licm
                     
hosting bitcast 
PyUnicode_AsRawUnicodeEscapeString
gvn
                     
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_AsRawUnicodeEscapeString
gvn
                     
load of type i16 not eliminated because it is clobbered by call 
PyUnicode_AsRawUnicodeEscapeString
6437
6438
        /* U+0000-U+00ff range: Copy 8-bit characters as-is */
6439
        if (ch < 0x100) {
6440
            *p++ = (char) ch;
6441
        }
6442
        /* U+0000-U+00ff range: Map 16-bit characters to '\uHHHH' */
6443
        else if (ch < 0x10000) {
loop-vectorize
                 
loop not vectorized: control flow cannot be substituted for a select 
PyUnicode_AsRawUnicodeEscapeString
6444
            *p++ = '\\';
6445
            *p++ = 'u';
6446
            *p++ = Py_hexdigits[(ch >> 12) & 0xf];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
6447
            *p++ = Py_hexdigits[(ch >> 8) & 0xf];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
6448
            *p++ = Py_hexdigits[(ch >> 4) & 0xf];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
6449
            *p++ = Py_hexdigits[ch & 15];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
6450
        }
loop-vectorize
        
loop not vectorized: control flow cannot be substituted for a select 
PyUnicode_AsRawUnicodeEscapeString
6451
        /* U+010000-U+10ffff range: Map 32-bit characters to '\U00HHHHHH' */
6452
        else {
6453
            assert(ch <= MAX_UNICODE && MAX_UNICODE <= 0x10ffff);
6454
            *p++ = '\\';
6455
            *p++ = 'U';
6456
            *p++ = '0';
6457
            *p++ = '0';
6458
            *p++ = Py_hexdigits[(ch >> 20) & 0xf];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
6459
            *p++ = Py_hexdigits[(ch >> 16) & 0xf];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
6460
            *p++ = Py_hexdigits[(ch >> 12) & 0xf];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
6461
            *p++ = Py_hexdigits[(ch >> 8) & 0xf];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
6462
            *p++ = Py_hexdigits[(ch >> 4) & 0xf];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
6463
            *p++ = Py_hexdigits[ch & 15];
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
6464
        }
6465
    }
6466
6467
    assert(p > PyBytes_AS_STRING(repr));
6468
    if (_PyBytes_Resize(&repr, p - PyBytes_AS_STRING(repr)) < 0) {
inline
        
_PyBytes_Resize will not be inlined into PyUnicode_AsRawUnicodeEscapeString because its definition is unavailable 
PyUnicode_AsRawUnicodeEscapeString
gvn
                                   
load of type %struct.PyBytesObject* not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
gvn
                                   
load of type %struct.PyBytesObject* not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
gvn
                                   
load of type %struct.PyBytesObject* not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
gvn
                                   
load of type %struct.PyBytesObject* not eliminated because it is clobbered by store 
PyUnicode_AsRawUnicodeEscapeString
6469
        return NULL;
6470
    }
6471
    return repr;
gvn
           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_AsRawUnicodeEscapeString
6472
}
6473
6474
PyObject *
6475
PyUnicode_EncodeRawUnicodeEscape(const Py_UNICODE *s,
6476
                                 Py_ssize_t size)
6477
{
6478
    PyObject *result;
6479
    PyObject *tmp = PyUnicode_FromUnicode(s, size);
inline
                    
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeRawUnicodeEscape
inline
                    
PyUnicode_FromUnicode will not be inlined into PyUnicode_EncodeRawUnicodeEscape 
PyUnicode_EncodeRawUnicodeEscape
6480
    if (tmp == NULL)
6481
        return NULL;
6482
    result = PyUnicode_AsRawUnicodeEscapeString(tmp);
inline
             
PyUnicode_AsRawUnicodeEscapeString too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeRawUnicodeEscape
inline
             
PyUnicode_AsRawUnicodeEscapeString will not be inlined into PyUnicode_EncodeRawUnicodeEscape 
PyUnicode_EncodeRawUnicodeEscape
6483
    Py_DECREF(tmp);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeRawUnicodeEscape
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeRawUnicodeEscape
6484
    return result;
6485
}
6486
6487
/* --- Unicode Internal Codec ------------------------------------------- */
6488
6489
PyObject *
6490
_PyUnicode_DecodeUnicodeInternal(const char *s,
6491
                                 Py_ssize_t size,
6492
                                 const char *errors)
6493
{
6494
    const char *starts = s;
6495
    Py_ssize_t startinpos;
6496
    Py_ssize_t endinpos;
6497
    _PyUnicodeWriter writer;
6498
    const char *end;
6499
    const char *reason;
6500
    PyObject *errorHandler = NULL;
6501
    PyObject *exc = NULL;
6502
6503
    if (PyErr_WarnEx(PyExc_DeprecationWarning,
inline
        
PyErr_WarnEx will not be inlined into _PyUnicode_DecodeUnicodeInternal because its definition is unavailable 
_PyUnicode_DecodeUnicodeInternal
6504
                     "unicode_internal codec has been deprecated",
6505
                     1))
6506
        return NULL;
6507
6508
    if (size == 0)
6509
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
_PyUnicode_DecodeUnicodeInternal
inline
        
PyUnicode_New will not be inlined into _PyUnicode_DecodeUnicodeInternal 
_PyUnicode_DecodeUnicodeInternal
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
        
load of type %struct._object* eliminated in favor of phi 
_PyUnicode_DecodeUnicodeInternal
6510
6511
    _PyUnicodeWriter_Init(&writer);
inline
    
_PyUnicodeWriter_Init can be inlined into _PyUnicode_DecodeUnicodeInternal with cost=-30 (threshold=375) 
_PyUnicode_DecodeUnicodeInternal
inline
    
_PyUnicodeWriter_Init inlined into _PyUnicode_DecodeUnicodeInternal 
_PyUnicode_DecodeUnicodeInternal
6512
    if (size / Py_UNICODE_SIZE > PY_SSIZE_T_MAX - 1) {
6513
        PyErr_NoMemory();
6514
        goto onError;
6515
    }
6516
    writer.min_length = (size + (Py_UNICODE_SIZE - 1)) / Py_UNICODE_SIZE;
6517
6518
    end = s + size;
gvn
          
load of type i8* eliminated in favor of  
_PyUnicode_DecodeUnicodeInternal
6519
    while (s < end) {
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeInternal
licm
               
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeInternal
gvn
           
load of type i8* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
               
load of type i8* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_DecodeUnicodeInternal
loop-vectorize
    
loop not vectorized 
_PyUnicode_DecodeUnicodeInternal
6520
        Py_UNICODE uch;
6521
        Py_UCS4 ch;
6522
        if (end - s < Py_UNICODE_SIZE) {
6523
            endinpos = end-starts;
licm
                           
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeInternal
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
6524
            reason = "truncated input";
6525
            goto error;
6526
        }
6527
        /* We copy the raw representation one byte at a time because the
6528
           pointer may be unaligned (see test_codeccallbacks). */
6529
        ((char *) &uch)[0] = s[0];
gvn
                             
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
6530
        ((char *) &uch)[1] = s[1];
6531
#ifdef Py_UNICODE_WIDE
6532
        ((char *) &uch)[2] = s[2];
6533
        ((char *) &uch)[3] = s[3];
6534
#endif
6535
        ch = uch;
6536
#ifdef Py_UNICODE_WIDE
6537
        /* We have to sanity check the raw data, otherwise doom looms for
6538
           some malformed UCS-4 data. */
6539
        if (ch > 0x10ffff) {
6540
            endinpos = s - starts + Py_UNICODE_SIZE;
licm
                           
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeInternal
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
6541
            reason = "illegal code point (> 0x10FFFF)";
6542
            goto error;
6543
        }
6544
#endif
6545
        s += Py_UNICODE_SIZE;
6546
#ifndef Py_UNICODE_WIDE
6547
        if (Py_UNICODE_IS_HIGH_SURROGATE(ch) && end - s >= Py_UNICODE_SIZE)
6548
        {
6549
            Py_UNICODE uch2;
6550
            ((char *) &uch2)[0] = s[0];
6551
            ((char *) &uch2)[1] = s[1];
6552
            if (Py_UNICODE_IS_LOW_SURROGATE(uch2))
6553
            {
6554
                ch = Py_UNICODE_JOIN_SURROGATES(uch, uch2);
6555
                s += Py_UNICODE_SIZE;
6556
            }
6557
        }
6558
#endif
6559
6560
        if (_PyUnicodeWriter_WriteCharInline(&writer, ch) < 0)
inline
            
_PyUnicodeWriter_WriteCharInline can be inlined into _PyUnicode_DecodeUnicodeInternal with cost=150 (threshold=325) 
_PyUnicode_DecodeUnicodeInternal
inline
            
_PyUnicodeWriter_WriteCharInline inlined into _PyUnicode_DecodeUnicodeInternal 
_PyUnicode_DecodeUnicodeInternal
6561
            goto onError;
6562
        continue;
6563
6564
  error:
6565
        startinpos = s - starts;
licm
                     
hosting bitcast 
_PyUnicode_DecodeUnicodeInternal
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeInternal
licm
                         
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeInternal
gvn
                     
load of type i64 eliminated in favor of phi 
_PyUnicode_DecodeUnicodeInternal
gvn
                         
load of type i64 eliminated in favor of phi 
_PyUnicode_DecodeUnicodeInternal
6566
        if (unicode_decode_call_errorhandler_writer(
inline
            
unicode_decode_call_errorhandler_writer too costly to inline (cost=630, threshold=625) 
_PyUnicode_DecodeUnicodeInternal
inline
            
unicode_decode_call_errorhandler_writer will not be inlined into _PyUnicode_DecodeUnicodeInternal 
_PyUnicode_DecodeUnicodeInternal
6567
                errors, &errorHandler,
6568
                "unicode_internal", reason,
6569
                &starts, &end, &startinpos, &endinpos, &exc, &s,
6570
                &writer))
6571
            goto onError;
6572
    }
6573
6574
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load eliminated by PRE 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
6575
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
6576
    return _PyUnicodeWriter_Finish(&writer);
inline
           
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
_PyUnicode_DecodeUnicodeInternal
inline
           
_PyUnicodeWriter_Finish will not be inlined into _PyUnicode_DecodeUnicodeInternal 
_PyUnicode_DecodeUnicodeInternal
6577
6578
  onError:
6579
    _PyUnicodeWriter_Dealloc(&writer);
inline
    
_PyUnicodeWriter_Dealloc can be inlined into _PyUnicode_DecodeUnicodeInternal with cost=20 (threshold=250) 
_PyUnicode_DecodeUnicodeInternal
inline
    
_PyUnicodeWriter_Dealloc inlined into _PyUnicode_DecodeUnicodeInternal 
_PyUnicode_DecodeUnicodeInternal
6580
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
6581
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
6582
    return NULL;
6583
}
6584
6585
/* --- Latin-1 Codec ------------------------------------------------------ */
6586
6587
PyObject *
6588
PyUnicode_DecodeLatin1(const char *s,
6589
                       Py_ssize_t size,
6590
                       const char *errors)
6591
{
6592
    /* Latin-1 is equivalent to the first 256 ordinals in Unicode. */
6593
    return _PyUnicode_FromUCS1((unsigned char*)s, size);
inline
           
_PyUnicode_FromUCS1 too costly to inline (cost=410, threshold=250) 
PyUnicode_DecodeLatin1
inline
           
_PyUnicode_FromUCS1 will not be inlined into PyUnicode_DecodeLatin1 
PyUnicode_DecodeLatin1
inline
           
_PyUnicode_FromUCS1 too costly to inline (cost=410, threshold=250) 
PyUnicode_Decode
inline
           
_PyUnicode_FromUCS1 will not be inlined into PyUnicode_Decode 
PyUnicode_Decode
inline
           
_PyUnicode_FromUCS1 too costly to inline (cost=410, threshold=250) 
PyUnicode_DecodeCharmap
inline
           
_PyUnicode_FromUCS1 will not be inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
6594
}
6595
6596
/* create or adjust a UnicodeEncodeError */
6597
static void
6598
make_encode_exception(PyObject **exceptionObject,
6599
                      const char *encoding,
6600
                      PyObject *unicode,
6601
                      Py_ssize_t startpos, Py_ssize_t endpos,
6602
                      const char *reason)
6603
{
6604
    if (*exceptionObject == NULL) {
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
ucs2lib_utf8_encoder
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
ucs4lib_utf8_encoder
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_AsUTF8String
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_encode_ucs1
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_encode_ucs1
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
6605
        *exceptionObject = PyObject_CallFunction(
inline
                           
_PyObject_CallFunction_SizeT will not be inlined into make_encode_exception because its definition is unavailable 
make_encode_exception
inline
                           
_PyObject_CallFunction_SizeT will not be inlined into PyUnicode_EncodeDecimal because its definition is unavailable 
PyUnicode_EncodeDecimal
6606
            PyExc_UnicodeEncodeError, "sOnns",
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
ucs2lib_utf8_encoder
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
ucs2lib_utf8_encoder
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
ucs4lib_utf8_encoder
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
ucs4lib_utf8_encoder
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_AsUTF8String
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_AsUTF8String
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
            
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_encode_ucs1
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
            
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_encode_ucs1
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
            
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_encode_ucs1
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_EncodeDecimal
6607
            encoding, unicode, startpos, endpos, reason);
6608
    }
6609
    else {
6610
        if (PyUnicodeEncodeError_SetStart(*exceptionObject, startpos))
inline
            
PyUnicodeEncodeError_SetStart will not be inlined into make_encode_exception because its definition is unavailable 
make_encode_exception
6611
            goto onError;
6612
        if (PyUnicodeEncodeError_SetEnd(*exceptionObject, endpos))
inline
            
PyUnicodeEncodeError_SetEnd will not be inlined into make_encode_exception because its definition is unavailable 
make_encode_exception
gvn
                                        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
make_encode_exception
gvn
                                        
load of type %struct._object* eliminated in favor of load 
ucs2lib_utf8_encoder
gvn
                                        
load of type %struct._object* eliminated in favor of load 
ucs4lib_utf8_encoder
gvn
                                        
load of type %struct._object* eliminated in favor of load 
_PyUnicode_EncodeUTF16
gvn
                                        
load of type %struct._object* eliminated in favor of load 
_PyUnicode_EncodeUTF32
gvn
                                        
load of type %struct._object* eliminated in favor of load 
unicode_encode_ucs1
gvn
                                        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
6613
            goto onError;
6614
        if (PyUnicodeEncodeError_SetReason(*exceptionObject, reason))
inline
            
PyUnicodeEncodeError_SetReason will not be inlined into make_encode_exception because its definition is unavailable 
make_encode_exception
gvn
                                           
load of type %struct._object* not eliminated because it is clobbered by call 
make_encode_exception
gvn
                                           
load of type %struct._object* eliminated in favor of load 
ucs2lib_utf8_encoder
gvn
                                           
load of type %struct._object* eliminated in favor of load 
ucs4lib_utf8_encoder
gvn
                                           
load of type %struct._object* eliminated in favor of load 
_PyUnicode_EncodeUTF16
gvn
                                           
load of type %struct._object* eliminated in favor of load 
_PyUnicode_EncodeUTF32
gvn
                                           
load of type %struct._object* eliminated in favor of load 
unicode_encode_ucs1
gvn
                                           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
6615
            goto onError;
6616
        return;
6617
      onError:
6618
        Py_CLEAR(*exceptionObject);
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
make_encode_exception
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
make_encode_exception
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
make_encode_exception
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
make_encode_exception
gvn
        
load of type %struct._object* eliminated in favor of load 
ucs2lib_utf8_encoder
gvn
        
load of type i64 not eliminated because it is clobbered by call 
ucs2lib_utf8_encoder
gvn
        
load of type i64 not eliminated because it is clobbered by call 
ucs2lib_utf8_encoder
gvn
        
load of type i64 not eliminated because it is clobbered by call 
ucs2lib_utf8_encoder
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
ucs2lib_utf8_encoder
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
ucs2lib_utf8_encoder
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
ucs2lib_utf8_encoder
gvn
        
load of type %struct._object* eliminated in favor of load 
ucs4lib_utf8_encoder
gvn
        
load of type i64 not eliminated because it is clobbered by call 
ucs4lib_utf8_encoder
gvn
        
load of type i64 not eliminated because it is clobbered by call 
ucs4lib_utf8_encoder
gvn
        
load of type i64 not eliminated because it is clobbered by call 
ucs4lib_utf8_encoder
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
ucs4lib_utf8_encoder
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
ucs4lib_utf8_encoder
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
ucs4lib_utf8_encoder
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_AsUTF8String
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_AsUTF8String
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_AsUTF8String
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_AsUTF8String
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_AsUTF8String
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_AsUTF8String
gvn
        
load of type %struct._object* eliminated in favor of load 
_PyUnicode_EncodeUTF16
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF16
gvn
        
load of type %struct._object* eliminated in favor of load 
_PyUnicode_EncodeUTF32
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeUTF32
gvn
        
load of type %struct._object* eliminated in favor of load 
unicode_encode_ucs1
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
6619
    }
6620
}
6621
6622
/* raises a UnicodeEncodeError */
6623
static void
6624
raise_encode_exception(PyObject **exceptionObject,
6625
                       const char *encoding,
6626
                       PyObject *unicode,
6627
                       Py_ssize_t startpos, Py_ssize_t endpos,
6628
                       const char *reason)
6629
{
6630
    make_encode_exception(exceptionObject,
inline
    
make_encode_exception too costly to inline (cost=255, threshold=250) 
raise_encode_exception
inline
    
make_encode_exception will not be inlined into raise_encode_exception 
raise_encode_exception
inline
    
make_encode_exception can be inlined into ucs2lib_utf8_encoder with cost=225 (threshold=250) 
ucs2lib_utf8_encoder
inline
    
make_encode_exception inlined into ucs2lib_utf8_encoder 
ucs2lib_utf8_encoder
inline
    
make_encode_exception can be inlined into ucs4lib_utf8_encoder with cost=225 (threshold=250) 
ucs4lib_utf8_encoder
inline
    
make_encode_exception inlined into ucs4lib_utf8_encoder 
ucs4lib_utf8_encoder
inline
    
make_encode_exception can be inlined into _PyUnicode_EncodeUTF16 with cost=225 (threshold=250) 
_PyUnicode_EncodeUTF16
inline
    
make_encode_exception inlined into _PyUnicode_EncodeUTF16 
_PyUnicode_EncodeUTF16
inline
    
make_encode_exception can be inlined into _PyUnicode_EncodeUTF32 with cost=225 (threshold=250) 
_PyUnicode_EncodeUTF32
inline
    
make_encode_exception inlined into _PyUnicode_EncodeUTF32 
_PyUnicode_EncodeUTF32
inline
    
make_encode_exception can be inlined into unicode_encode_ucs1 with cost=225 (threshold=250) 
unicode_encode_ucs1
inline
    
make_encode_exception inlined into unicode_encode_ucs1 
unicode_encode_ucs1
inline
    
make_encode_exception too costly to inline (cost=255, threshold=250) 
charmap_encoding_error
inline
    
make_encode_exception will not be inlined into charmap_encoding_error 
charmap_encoding_error
inline
    
make_encode_exception can be inlined into _PyUnicode_EncodeCharmap with cost=225 (threshold=250) 
_PyUnicode_EncodeCharmap
inline
    
make_encode_exception inlined into _PyUnicode_EncodeCharmap 
_PyUnicode_EncodeCharmap
inline
    
make_encode_exception can be inlined into PyUnicode_EncodeDecimal with cost=225 (threshold=250) 
PyUnicode_EncodeDecimal
inline
    
make_encode_exception inlined into PyUnicode_EncodeDecimal 
PyUnicode_EncodeDecimal
6631
                          encoding, unicode, startpos, endpos, reason);
6632
    if (*exceptionObject != NULL)
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
raise_encode_exception
gvn
        
load of type %struct._object* eliminated in favor of phi 
ucs2lib_utf8_encoder
gvn
        
load of type %struct._object* eliminated in favor of phi 
ucs4lib_utf8_encoder
gvn
        
load of type %struct._object* eliminated in favor of phi 
_PyUnicode_EncodeUTF16
gvn
        
load of type %struct._object* eliminated in favor of phi 
_PyUnicode_EncodeUTF32
gvn
        
load of type %struct._object* eliminated in favor of phi 
unicode_encode_ucs1
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
6633
        PyCodec_StrictErrors(*exceptionObject);
inline
        
PyCodec_StrictErrors will not be inlined into raise_encode_exception because its definition is unavailable 
raise_encode_exception
inline
        
PyCodec_StrictErrors will not be inlined into PyUnicode_EncodeDecimal because its definition is unavailable 
PyUnicode_EncodeDecimal
6634
}
6635
6636
/* error handling callback helper:
6637
   build arguments, call the callback and check the arguments,
6638
   put the result into newpos and return the replacement string, which
6639
   has to be freed by the caller */
6640
static PyObject *
6641
unicode_encode_call_errorhandler(const char *errors,
6642
                                 PyObject **errorHandler,
6643
                                 const char *encoding, const char *reason,
6644
                                 PyObject *unicode, PyObject **exceptionObject,
6645
                                 Py_ssize_t startpos, Py_ssize_t endpos,
6646
                                 Py_ssize_t *newpos)
6647
{
6648
    static const char *argparse = "On;encoding error handler must return (str/bytes, int) tuple";
6649
    Py_ssize_t len;
6650
    PyObject *restuple;
6651
    PyObject *resunicode;
6652
6653
    if (*errorHandler == NULL) {
6654
        *errorHandler = PyCodec_LookupError(errors);
inline
                        
PyCodec_LookupError will not be inlined into unicode_encode_call_errorhandler because its definition is unavailable 
unicode_encode_call_errorhandler
6655
        if (*errorHandler == NULL)
6656
            return NULL;
6657
    }
6658
6659
    if (PyUnicode_READY(unicode) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_encode_call_errorhandler
inline
        
_PyUnicode_Ready will not be inlined into unicode_encode_call_errorhandler 
unicode_encode_call_errorhandler
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_encode_call_errorhandler
6660
        return NULL;
6661
    len = PyUnicode_GET_LENGTH(unicode);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_call_errorhandler
gvn
          
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_call_errorhandler
6662
6663
    make_encode_exception(exceptionObject,
inline
    
make_encode_exception too costly to inline (cost=255, threshold=250) 
unicode_encode_call_errorhandler
inline
    
make_encode_exception will not be inlined into unicode_encode_call_errorhandler 
unicode_encode_call_errorhandler
6664
                          encoding, unicode, startpos, endpos, reason);
6665
    if (*exceptionObject == NULL)
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_encode_call_errorhandler
6666
        return NULL;
6667
6668
    restuple = PyObject_CallFunctionObjArgs(
inline
               
PyObject_CallFunctionObjArgs will not be inlined into unicode_encode_call_errorhandler because its definition is unavailable 
unicode_encode_call_errorhandler
6669
        *errorHandler, *exceptionObject, NULL);
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_encode_call_errorhandler
6670
    if (restuple == NULL)
6671
        return NULL;
6672
    if (!PyTuple_Check(restuple)) {
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_encode_call_errorhandler
6673
        PyErr_SetString(PyExc_TypeError, &argparse[3]);
inline
        
PyErr_SetString will not be inlined into unicode_encode_call_errorhandler because its definition is unavailable 
unicode_encode_call_errorhandler
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_encode_call_errorhandler
6674
        Py_DECREF(restuple);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_call_errorhandler
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_call_errorhandler
6675
        return NULL;
6676
    }
6677
    if (!PyArg_ParseTuple(restuple, argparse,
inline
         
_PyArg_ParseTuple_SizeT will not be inlined into unicode_encode_call_errorhandler because its definition is unavailable 
unicode_encode_call_errorhandler
6678
                          &resunicode, newpos)) {
6679
        Py_DECREF(restuple);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_call_errorhandler
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_call_errorhandler
6680
        return NULL;
6681
    }
6682
    if (!PyUnicode_Check(resunicode) && !PyBytes_Check(resunicode)) {
gvn
         
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_encode_call_errorhandler
6683
        PyErr_SetString(PyExc_TypeError, &argparse[3]);
inline
        
PyErr_SetString will not be inlined into unicode_encode_call_errorhandler because its definition is unavailable 
unicode_encode_call_errorhandler
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_encode_call_errorhandler
6684
        Py_DECREF(restuple);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_call_errorhandler
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_call_errorhandler
6685
        return NULL;
6686
    }
6687
    if (*newpos<0)
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_call_errorhandler
6688
        *newpos = len + *newpos;
6689
    if (*newpos<0 || *newpos>len) {
gvn
        
load of type i64 eliminated in favor of phi 
unicode_encode_call_errorhandler
6690
        PyErr_Format(PyExc_IndexError, "position %zd from error handler out of bounds", *newpos);
inline
        
PyErr_Format will not be inlined into unicode_encode_call_errorhandler because its definition is unavailable 
unicode_encode_call_errorhandler
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_encode_call_errorhandler
6691
        Py_DECREF(restuple);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_call_errorhandler
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_call_errorhandler
6692
        return NULL;
6693
    }
6694
    Py_INCREF(resunicode);
gvn
    
load of type %struct._object* eliminated in favor of load 
unicode_encode_call_errorhandler
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_encode_call_errorhandler
6695
    Py_DECREF(restuple);
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_encode_call_errorhandler
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_call_errorhandler
6696
    return resunicode;
gvn
           
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_encode_call_errorhandler
gvn
           
load eliminated by PRE 
unicode_encode_call_errorhandler
6697
}
6698
6699
static PyObject *
6700
unicode_encode_ucs1(PyObject *unicode,
6701
                    const char *errors,
6702
                    const Py_UCS4 limit)
6703
{
6704
    /* input state */
6705
    Py_ssize_t pos=0, size;
6706
    int kind;
6707
    void *data;
6708
    /* pointer into the output */
6709
    char *str;
6710
    const char *encoding = (limit == 256) ? "latin-1" : "ascii";
6711
    const char *reason = (limit == 256) ? "ordinal not in range(256)" : "ordinal not in range(128)";
6712
    PyObject *error_handler_obj = NULL;
6713
    PyObject *exc = NULL;
6714
    _Py_error_handler error_handler = _Py_ERROR_UNKNOWN;
6715
    PyObject *rep = NULL;
6716
    /* output object */
6717
    _PyBytesWriter writer;
6718
6719
    if (PyUnicode_READY(unicode) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_encode_ucs1
inline
        
_PyUnicode_Ready will not be inlined into unicode_encode_ucs1 
unicode_encode_ucs1
6720
        return NULL;
6721
    size = PyUnicode_GET_LENGTH(unicode);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
6722
    kind = PyUnicode_KIND(unicode);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
           
load eliminated by PRE 
unicode_encode_ucs1
6723
    data = PyUnicode_DATA(unicode);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_encode_ucs1
6724
    /* allocate enough for a simple encoding without
6725
       replacements, if we need more, we'll resize */
6726
    if (size == 0)
6727
        return PyBytes_FromStringAndSize(NULL, 0);
inline
               
PyBytes_FromStringAndSize will not be inlined into unicode_encode_ucs1 because its definition is unavailable 
unicode_encode_ucs1
6728
6729
    _PyBytesWriter_Init(&writer);
inline
    
_PyBytesWriter_Init will not be inlined into unicode_encode_ucs1 because its definition is unavailable 
unicode_encode_ucs1
6730
    str = _PyBytesWriter_Alloc(&writer, size);
inline
          
_PyBytesWriter_Alloc will not be inlined into unicode_encode_ucs1 because its definition is unavailable 
unicode_encode_ucs1
6731
    if (str == NULL)
6732
        return NULL;
6733
6734
    while (pos < size) {
6735
        Py_UCS4 ch = PyUnicode_READ(kind, data, pos);
licm
                     
hosting icmp 
unicode_encode_ucs1
licm
                     
hosting bitcast 
unicode_encode_ucs1
loop-vectorize
                     
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_encode_ucs1
loop-vectorize
                     
loop not vectorized 
unicode_encode_ucs1
6736
6737
        /* can we encode this? */
6738
        if (ch < limit) {
6739
            /* no overflow check, because we know that the space is enough */
6740
            *str++ = (char)ch;
6741
            ++pos;
6742
        }
6743
        else {
6744
            Py_ssize_t newpos, i;
licm
            
hosting bitcast 
unicode_encode_ucs1
6745
            /* startpos for collecting unencodable chars */
6746
            Py_ssize_t collstart = pos;
6747
            Py_ssize_t collend = collstart + 1;
6748
            /* find all unecodable characters */
6749
6750
            while ((collend < size) && (PyUnicode_READ(kind, data, collend) >= limit))
licm
                                        
hosting icmp 
unicode_encode_ucs1
licm
                                        
hosting bitcast 
unicode_encode_ucs1
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_encode_ucs1
loop-vectorize
            
loop not vectorized 
unicode_encode_ucs1
6751
                ++collend;
6752
6753
            /* Only overallocate the buffer if it's not the last write */
6754
            writer.overallocate = (collend < size);
licm
                   
hosting getelementptr 
unicode_encode_ucs1
6755
6756
            /* cache callback name lookup (if not done yet, i.e. it's the first error) */
6757
            if (error_handler == _Py_ERROR_UNKNOWN)
6758
                error_handler = get_error_handler(errors);
inline
                                
get_error_handler too costly to inline (cost=325, threshold=250) 
unicode_encode_ucs1
inline
                                
get_error_handler will not be inlined into unicode_encode_ucs1 
unicode_encode_ucs1
6759
6760
            switch (error_handler) {
6761
            case _Py_ERROR_STRICT:
6762
                raise_encode_exception(&exc, encoding, unicode, collstart, collend, reason);
inline
                
raise_encode_exception can be inlined into unicode_encode_ucs1 with cost=50 (threshold=250) 
unicode_encode_ucs1
inline
                
raise_encode_exception inlined into unicode_encode_ucs1 
unicode_encode_ucs1
6763
                goto onError;
6764
6765
            case _Py_ERROR_REPLACE:
6766
                memset(str, '?', collend - collstart);
6767
                str += (collend - collstart);
6768
                /* fall through ignore error handler */
6769
            case _Py_ERROR_IGNORE:
6770
                pos = collend;
6771
                break;
6772
6773
            case _Py_ERROR_BACKSLASHREPLACE:
6774
                /* subtract preallocated bytes */
6775
                writer.min_size -= (collend - collstart);
licm
                       
hosting getelementptr 
unicode_encode_ucs1
licm
                                
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by store 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by store 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by store 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
6776
                str = backslashreplace(&writer, str,
inline
                      
backslashreplace too costly to inline (cost=630, threshold=625) 
unicode_encode_ucs1
inline
                      
backslashreplace will not be inlined into unicode_encode_ucs1 
unicode_encode_ucs1
6777
                                       unicode, collstart, collend);
6778
                if (str == NULL)
6779
                    goto onError;
6780
                pos = collend;
6781
                break;
6782
6783
            case _Py_ERROR_XMLCHARREFREPLACE:
6784
                /* subtract preallocated bytes */
6785
                writer.min_size -= (collend - collstart);
licm
                       
hosting getelementptr 
unicode_encode_ucs1
licm
                                
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by store 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by store 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by store 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
6786
                str = xmlcharrefreplace(&writer, str,
inline
                      
xmlcharrefreplace too costly to inline (cost=630, threshold=625) 
unicode_encode_ucs1
inline
                      
xmlcharrefreplace will not be inlined into unicode_encode_ucs1 
unicode_encode_ucs1
6787
                                        unicode, collstart, collend);
6788
                if (str == NULL)
6789
                    goto onError;
6790
                pos = collend;
6791
                break;
6792
6793
            case _Py_ERROR_SURROGATEESCAPE:
6794
                for (i = collstart; i < collend; ++i) {
loop-unroll
                
completely unrolled loop with 1 iterations 
unicode_encode_ucs1
loop-vectorize
                
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_encode_ucs1
loop-vectorize
                
loop not vectorized 
unicode_encode_ucs1
6795
                    ch = PyUnicode_READ(kind, data, i);
licm
                         
hosting icmp 
unicode_encode_ucs1
licm
                         
hosting bitcast 
unicode_encode_ucs1
6796
                    if (ch < 0xdc80 || 0xdcff < ch) {
6797
                        /* Not a UTF-8b surrogate */
6798
                        break;
6799
                    }
6800
                    *str++ = (char)(ch - 0xdc00);
6801
                    ++pos;
6802
                }
6803
                if (i >= collend)
6804
                    break;
6805
                collstart = pos;
6806
                assert(collstart != collend);
6807
                /* fallback to general error handling */
6808
6809
            default:
6810
                rep = unicode_encode_call_errorhandler(errors, &error_handler_obj,
inline
                      
unicode_encode_call_errorhandler too costly to inline (cost=630, threshold=625) 
unicode_encode_ucs1
inline
                      
unicode_encode_call_errorhandler will not be inlined into unicode_encode_ucs1 
unicode_encode_ucs1
6811
                                                       encoding, reason, unicode, &exc,
6812
                                                       collstart, collend, &newpos);
6813
                if (rep == NULL)
6814
                    goto onError;
6815
6816
                /* subtract preallocated bytes */
6817
                writer.min_size -= 1;
licm
                       
hosting getelementptr 
unicode_encode_ucs1
licm
                                
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_encode_ucs1
gvn
                                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
6818
6819
                if (PyBytes_Check(rep)) {
gvn
                    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_encode_ucs1
6820
                    /* Directly copy bytes result to output. */
6821
                    str = _PyBytesWriter_WriteBytes(&writer, str,
inline
                          
_PyBytesWriter_WriteBytes will not be inlined into unicode_encode_ucs1 because its definition is unavailable 
unicode_encode_ucs1
6822
                                                    PyBytes_AS_STRING(rep),
6823
                                                    PyBytes_GET_SIZE(rep));
gvn
                                                    
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
6824
                    if (str == NULL)
6825
                        goto onError;
6826
                }
6827
                else {
6828
                    assert(PyUnicode_Check(rep));
6829
6830
                    if (PyUnicode_READY(rep) < 0)
inline
                        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_encode_ucs1
inline
                        
_PyUnicode_Ready will not be inlined into unicode_encode_ucs1 
unicode_encode_ucs1
gvn
                        
load of type i32 not eliminated because it is clobbered by call 
unicode_encode_ucs1
6831
                        goto onError;
6832
6833
                    if (PyUnicode_IS_ASCII(rep)) {
gvn
                        
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
                        
load eliminated by PRE 
unicode_encode_ucs1
6834
                        /* Fast path: all characters are smaller than limit */
6835
                        assert(limit >= 128);
6836
                        assert(PyUnicode_KIND(rep) == PyUnicode_1BYTE_KIND);
6837
                        str = _PyBytesWriter_WriteBytes(&writer, str,
inline
                              
_PyBytesWriter_WriteBytes will not be inlined into unicode_encode_ucs1 because its definition is unavailable 
unicode_encode_ucs1
6838
                                                        PyUnicode_DATA(rep),
gvn
                                                        
load of type i8* not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                                        
load of type i8* not eliminated because it is clobbered by call 
unicode_encode_ucs1
6839
                                                        PyUnicode_GET_LENGTH(rep));
gvn
                                                        
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                                        
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
6840
                    }
6841
                    else {
6842
                        Py_ssize_t repsize = PyUnicode_GET_LENGTH(rep);
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
6843
6844
                        str = _PyBytesWriter_Prepare(&writer, str, repsize);
inline
                              
_PyBytesWriter_Prepare will not be inlined into unicode_encode_ucs1 because its definition is unavailable 
unicode_encode_ucs1
6845
                        if (str == NULL)
6846
                            goto onError;
6847
6848
                        /* check if there is anything unencodable in the
6849
                           replacement and copy it to the output */
6850
                        for (i = 0; repsize-->0; ++i, ++str) {
loop-vectorize
                        
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_encode_ucs1
loop-vectorize
                        
loop not vectorized 
unicode_encode_ucs1
6851
                            ch = PyUnicode_READ_CHAR(rep, i);
licm
                                 
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_encode_ucs1
licm
                                 
hosting getelementptr 
unicode_encode_ucs1
licm
                                 
hosting bitcast 
unicode_encode_ucs1
gvn
                                 
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_encode_ucs1
gvn
                                 
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
                                 
load of type i8* not eliminated because it is clobbered by store 
unicode_encode_ucs1
gvn
                                 
load of type i8* not eliminated because it is clobbered by call 
unicode_encode_ucs1
6852
                            if (ch >= limit) {
6853
                                raise_encode_exception(&exc, encoding, unicode,
inline
                                
raise_encode_exception can be inlined into unicode_encode_ucs1 with cost=50 (threshold=250) 
unicode_encode_ucs1
inline
                                
raise_encode_exception inlined into unicode_encode_ucs1 
unicode_encode_ucs1
6854
                                                       pos, pos+1, reason);
6855
                                goto onError;
6856
                            }
6857
                            *str = (char)ch;
6858
                        }
6859
                    }
6860
                }
6861
                pos = newpos;
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_encode_ucs1
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                      
load of type i64 not eliminated because it is clobbered by store 
unicode_encode_ucs1
6862
                Py_CLEAR(rep);
gvn
                
load of type i64 not eliminated because it is clobbered by store 
unicode_encode_ucs1
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
                
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
                
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
                
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
                
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by store 
unicode_encode_ucs1
6863
            }
6864
6865
            /* If overallocation was disabled, ensure that it was the last
6866
               write. Otherwise, we missed an optimization */
6867
            assert(writer.overallocate || pos == size);
6868
        }
6869
    }
6870
6871
    Py_XDECREF(error_handler_obj);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
6872
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
6873
    return _PyBytesWriter_Finish(&writer, str);
inline
           
_PyBytesWriter_Finish will not be inlined into unicode_encode_ucs1 because its definition is unavailable 
unicode_encode_ucs1
6874
6875
  onError:
6876
    Py_XDECREF(rep);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_encode_ucs1
6877
    _PyBytesWriter_Dealloc(&writer);
inline
    
_PyBytesWriter_Dealloc will not be inlined into unicode_encode_ucs1 because its definition is unavailable 
unicode_encode_ucs1
6878
    Py_XDECREF(error_handler_obj);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_encode_ucs1
6879
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_encode_ucs1
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
unicode_encode_ucs1
6880
    return NULL;
6881
}
6882
6883
/* Deprecated */
6884
PyObject *
6885
PyUnicode_EncodeLatin1(const Py_UNICODE *p,
6886
                       Py_ssize_t size,
6887
                       const char *errors)
6888
{
6889
    PyObject *result;
6890
    PyObject *unicode = PyUnicode_FromUnicode(p, size);
inline
                        
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeLatin1
inline
                        
PyUnicode_FromUnicode will not be inlined into PyUnicode_EncodeLatin1 
PyUnicode_EncodeLatin1
6891
    if (unicode == NULL)
6892
        return NULL;
6893
    result = unicode_encode_ucs1(unicode, errors, 256);
inline
             
unicode_encode_ucs1 too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeLatin1
inline
             
unicode_encode_ucs1 will not be inlined into PyUnicode_EncodeLatin1 
PyUnicode_EncodeLatin1
6894
    Py_DECREF(unicode);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeLatin1
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeLatin1
6895
    return result;
6896
}
6897
6898
PyObject *
6899
_PyUnicode_AsLatin1String(PyObject *unicode, const char *errors)
6900
{
6901
    if (!PyUnicode_Check(unicode)) {
gvn
         
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsEncodedString
6902
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into _PyUnicode_AsLatin1String because its definition is unavailable 
_PyUnicode_AsLatin1String
6903
        return NULL;
6904
    }
6905
    if (PyUnicode_READY(unicode) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_AsLatin1String
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_AsLatin1String 
_PyUnicode_AsLatin1String
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_AsEncodedString
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_AsEncodedString 
PyUnicode_AsEncodedString
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_AsEncodedString
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_AsLatin1String
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_AsLatin1String 
PyUnicode_AsLatin1String
6906
        return NULL;
6907
    /* Fast path: if it is a one-byte string, construct
6908
       bytes object directly. */
6909
    if (PyUnicode_KIND(unicode) == PyUnicode_1BYTE_KIND)
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_AsLatin1String
gvn
        
load eliminated by PRE 
_PyUnicode_AsLatin1String
6910
        return PyBytes_FromStringAndSize(PyUnicode_DATA(unicode),
inline
               
PyBytes_FromStringAndSize will not be inlined into _PyUnicode_AsLatin1String because its definition is unavailable 
_PyUnicode_AsLatin1String
gvn
                                         
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_AsLatin1String
gvn
                                         
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_AsEncodedString
gvn
                                         
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
gvn
                                         
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_AsLatin1String
6911
                                         PyUnicode_GET_LENGTH(unicode));
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_AsLatin1String
gvn
                                         
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_AsEncodedString
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsLatin1String
6912
    /* Non-Latin-1 characters present. Defer to above function to
6913
       raise the exception. */
6914
    return unicode_encode_ucs1(unicode, errors, 256);
inline
           
unicode_encode_ucs1 too costly to inline (cost=630, threshold=625) 
_PyUnicode_AsLatin1String
inline
           
unicode_encode_ucs1 will not be inlined into _PyUnicode_AsLatin1String 
_PyUnicode_AsLatin1String
inline
           
unicode_encode_ucs1 too costly to inline (cost=630, threshold=625) 
PyUnicode_AsEncodedString
inline
           
unicode_encode_ucs1 will not be inlined into PyUnicode_AsEncodedString 
PyUnicode_AsEncodedString
inline
           
unicode_encode_ucs1 too costly to inline (cost=630, threshold=625) 
PyUnicode_AsLatin1String
inline
           
unicode_encode_ucs1 will not be inlined into PyUnicode_AsLatin1String 
PyUnicode_AsLatin1String
6915
}
6916
6917
PyObject*
6918
PyUnicode_AsLatin1String(PyObject *unicode)
6919
{
6920
    return _PyUnicode_AsLatin1String(unicode, NULL);
inline
           
_PyUnicode_AsLatin1String can be inlined into PyUnicode_AsLatin1String with cost=220 (threshold=250) 
PyUnicode_AsLatin1String
inline
           
_PyUnicode_AsLatin1String inlined into PyUnicode_AsLatin1String 
PyUnicode_AsLatin1String
6921
}
6922
6923
/* --- 7-bit ASCII Codec -------------------------------------------------- */
6924
6925
PyObject *
6926
PyUnicode_DecodeASCII(const char *s,
6927
                      Py_ssize_t size,
6928
                      const char *errors)
6929
{
6930
    const char *starts = s;
6931
    _PyUnicodeWriter writer;
6932
    int kind;
6933
    void *data;
6934
    Py_ssize_t startinpos;
6935
    Py_ssize_t endinpos;
6936
    Py_ssize_t outpos;
6937
    const char *e;
6938
    PyObject *error_handler_obj = NULL;
6939
    PyObject *exc = NULL;
6940
    _Py_error_handler error_handler = _Py_ERROR_UNKNOWN;
6941
6942
    if (size == 0)
6943
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_DecodeASCII
inline
        
PyUnicode_New will not be inlined into PyUnicode_DecodeASCII 
PyUnicode_DecodeASCII
gvn
        
load of type %struct._object* eliminated in favor of phi 
PyUnicode_DecodeASCII
6944
6945
    /* ASCII is equivalent to the first 128 ordinals in Unicode. */
6946
    if (size == 1 && (unsigned char)s[0] < 128)
gvn
                                    
load of type i8* eliminated in favor of  
PyUnicode_DecodeASCII
6947
        return get_latin1_char((unsigned char)s[0]);
inline
               
get_latin1_char can be inlined into PyUnicode_DecodeASCII with cost=110 (threshold=250) 
PyUnicode_DecodeASCII
inline
               
get_latin1_char inlined into PyUnicode_DecodeASCII 
PyUnicode_DecodeASCII
6948
6949
    _PyUnicodeWriter_Init(&writer);
inline
    
_PyUnicodeWriter_Init can be inlined into PyUnicode_DecodeASCII with cost=-30 (threshold=375) 
PyUnicode_DecodeASCII
inline
    
_PyUnicodeWriter_Init inlined into PyUnicode_DecodeASCII 
PyUnicode_DecodeASCII
6950
    writer.min_length = size;
6951
    if (_PyUnicodeWriter_Prepare(&writer, writer.min_length, 127) < 0)
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeASCII
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeASCII 
PyUnicode_DecodeASCII
gvn
        
load of type i32 eliminated in favor of 0 
PyUnicode_DecodeASCII
6952
        return NULL;
6953
6954
    e = s + size;
gvn
        
load of type i8* eliminated in favor of  
PyUnicode_DecodeASCII
6955
    data = writer.data;
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
                  
load eliminated by PRE 
PyUnicode_DecodeASCII
6956
    outpos = ascii_decode(s, e, (Py_UCS1 *)data);
inline
             
ascii_decode can be inlined into PyUnicode_DecodeASCII with cost=-14835 (threshold=250) 
PyUnicode_DecodeASCII
inline
             
ascii_decode inlined into PyUnicode_DecodeASCII 
PyUnicode_DecodeASCII
6957
    writer.pos = outpos;
6958
    if (writer.pos == size)
6959
        return _PyUnicodeWriter_Finish(&writer);
inline
               
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
PyUnicode_DecodeASCII
inline
               
_PyUnicodeWriter_Finish will not be inlined into PyUnicode_DecodeASCII 
PyUnicode_DecodeASCII
6960
6961
    s += writer.pos;
gvn
      
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
6962
    kind = writer.kind;
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
6963
    while (s < e) {
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
licm
               
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
               
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
gvn
               
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeASCII
gvn
           
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
           
load eliminated by PRE 
PyUnicode_DecodeASCII
gvn
               
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
               
load eliminated by PRE 
PyUnicode_DecodeASCII
gvn
               
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeASCII
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeASCII
loop-vectorize
    
loop not vectorized 
PyUnicode_DecodeASCII
6964
        unsigned char c = (unsigned char)*s;
gvn
                                         
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeASCII
gvn
                                         
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeASCII
6965
        if (c < 128) {
licm
            
sinking zext 
PyUnicode_DecodeASCII
6966
            PyUnicode_WRITE(kind, data, writer.pos, c);
licm
            
hosting bitcast 
PyUnicode_DecodeASCII
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeASCII
6967
            writer.pos++;
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
                      
load of type i64 eliminated in favor of load 
PyUnicode_DecodeASCII
gvn
                      
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeASCII
6968
            ++s;
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
            
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeASCII
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
6969
            continue;
6970
        }
6971
6972
        /* byte outsize range 0x00..0x7f: call the error handler */
6973
6974
        if (error_handler == _Py_ERROR_UNKNOWN)
6975
            error_handler = get_error_handler(errors);
inline
                            
get_error_handler too costly to inline (cost=325, threshold=250) 
PyUnicode_DecodeASCII
inline
                            
get_error_handler will not be inlined into PyUnicode_DecodeASCII 
PyUnicode_DecodeASCII
6976
6977
        switch (error_handler)
6978
        {
6979
        case _Py_ERROR_REPLACE:
6980
        case _Py_ERROR_SURROGATEESCAPE:
6981
            /* Fast-path: the error handler only writes one character,
6982
               but we may switch to UCS2 at the first write */
6983
            if (_PyUnicodeWriter_PrepareKind(&writer, PyUnicode_2BYTE_KIND) < 0)
inline
                
_PyUnicodeWriter_PrepareKindInternal can be inlined into PyUnicode_DecodeASCII with cost=5 (threshold=375) 
PyUnicode_DecodeASCII
inline
                
_PyUnicodeWriter_PrepareKindInternal inlined into PyUnicode_DecodeASCII 
PyUnicode_DecodeASCII
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
                
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeASCII
gvn
                
load eliminated by PRE 
PyUnicode_DecodeASCII
6984
                goto onError;
6985
            kind = writer.kind;
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeASCII
6986
            data = writer.data;
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
                          
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeASCII
gvn
                          
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeASCII
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeASCII
6987
6988
            if (error_handler == _Py_ERROR_REPLACE)
6989
                PyUnicode_WRITE(kind, data, writer.pos, 0xfffd);
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
                
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
                
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeASCII
6990
            else
6991
                PyUnicode_WRITE(kind, data, writer.pos, c + 0xdc00);
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
                
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
                
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeASCII
6992
            writer.pos++;
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
                      
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeASCII
6993
            ++s;
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
            
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeASCII
6994
            break;
6995
6996
        case _Py_ERROR_IGNORE:
6997
            ++s;
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
            
load of type i8* eliminated in favor of phi 
PyUnicode_DecodeASCII
6998
            break;
6999
7000
        default:
7001
            startinpos = s-starts;
licm
                         
hosting bitcast 
PyUnicode_DecodeASCII
licm
                         
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
licm
                           
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
                         
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeASCII
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
7002
            endinpos = startinpos + 1;
7003
            if (unicode_decode_call_errorhandler_writer(
inline
                
unicode_decode_call_errorhandler_writer too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeASCII
inline
                
unicode_decode_call_errorhandler_writer will not be inlined into PyUnicode_DecodeASCII 
PyUnicode_DecodeASCII
7004
                    errors, &error_handler_obj,
7005
                    "ascii", "ordinal not in range(128)",
7006
                    &starts, &e, &startinpos, &endinpos, &exc, &s,
7007
                    &writer))
7008
                goto onError;
7009
            kind = writer.kind;
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeASCII
7010
            data = writer.data;
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeASCII
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeASCII
7011
        }
7012
    }
7013
    Py_XDECREF(error_handler_obj);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeASCII
7014
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeASCII
7015
    return _PyUnicodeWriter_Finish(&writer);
inline
           
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
PyUnicode_DecodeASCII
inline
           
_PyUnicodeWriter_Finish will not be inlined into PyUnicode_DecodeASCII 
PyUnicode_DecodeASCII
7016
7017
  onError:
7018
    _PyUnicodeWriter_Dealloc(&writer);
inline
    
_PyUnicodeWriter_Dealloc can be inlined into PyUnicode_DecodeASCII with cost=20 (threshold=250) 
PyUnicode_DecodeASCII
inline
    
_PyUnicodeWriter_Dealloc inlined into PyUnicode_DecodeASCII 
PyUnicode_DecodeASCII
7019
    Py_XDECREF(error_handler_obj);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
7020
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeASCII
7021
    return NULL;
7022
}
7023
7024
/* Deprecated */
7025
PyObject *
7026
PyUnicode_EncodeASCII(const Py_UNICODE *p,
7027
                      Py_ssize_t size,
7028
                      const char *errors)
7029
{
7030
    PyObject *result;
7031
    PyObject *unicode = PyUnicode_FromUnicode(p, size);
inline
                        
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeASCII
inline
                        
PyUnicode_FromUnicode will not be inlined into PyUnicode_EncodeASCII 
PyUnicode_EncodeASCII
7032
    if (unicode == NULL)
7033
        return NULL;
7034
    result = unicode_encode_ucs1(unicode, errors, 128);
inline
             
unicode_encode_ucs1 too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeASCII
inline
             
unicode_encode_ucs1 will not be inlined into PyUnicode_EncodeASCII 
PyUnicode_EncodeASCII
7035
    Py_DECREF(unicode);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeASCII
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeASCII
7036
    return result;
7037
}
7038
7039
PyObject *
7040
_PyUnicode_AsASCIIString(PyObject *unicode, const char *errors)
7041
{
7042
    if (!PyUnicode_Check(unicode)) {
gvn
         
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by store 
PyUnicode_AsEncodedString
7043
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into _PyUnicode_AsASCIIString because its definition is unavailable 
_PyUnicode_AsASCIIString
7044
        return NULL;
7045
    }
7046
    if (PyUnicode_READY(unicode) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_AsASCIIString
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_AsASCIIString 
_PyUnicode_AsASCIIString
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_AsEncodedString
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_AsEncodedString 
PyUnicode_AsEncodedString
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_AsEncodedString
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_AsASCIIString
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_AsASCIIString 
PyUnicode_AsASCIIString
7047
        return NULL;
7048
    /* Fast path: if it is an ASCII-only string, construct bytes object
7049
       directly. Else defer to above function to raise the exception. */
7050
    if (PyUnicode_IS_ASCII(unicode))
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_AsASCIIString
gvn
        
load eliminated by PRE 
_PyUnicode_AsASCIIString
7051
        return PyBytes_FromStringAndSize(PyUnicode_DATA(unicode),
inline
               
PyBytes_FromStringAndSize will not be inlined into _PyUnicode_AsASCIIString because its definition is unavailable 
_PyUnicode_AsASCIIString
gvn
                                         
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_AsASCIIString
gvn
                                         
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_AsEncodedString
gvn
                                         
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
gvn
                                         
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_AsASCIIString
7052
                                         PyUnicode_GET_LENGTH(unicode));
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_AsASCIIString
gvn
                                         
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_AsEncodedString
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsEncodedString
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsASCIIString
7053
    return unicode_encode_ucs1(unicode, errors, 128);
inline
           
unicode_encode_ucs1 too costly to inline (cost=630, threshold=625) 
_PyUnicode_AsASCIIString
inline
           
unicode_encode_ucs1 will not be inlined into _PyUnicode_AsASCIIString 
_PyUnicode_AsASCIIString
inline
           
unicode_encode_ucs1 too costly to inline (cost=630, threshold=625) 
PyUnicode_AsEncodedString
inline
           
unicode_encode_ucs1 will not be inlined into PyUnicode_AsEncodedString 
PyUnicode_AsEncodedString
inline
           
unicode_encode_ucs1 too costly to inline (cost=630, threshold=625) 
PyUnicode_AsASCIIString
inline
           
unicode_encode_ucs1 will not be inlined into PyUnicode_AsASCIIString 
PyUnicode_AsASCIIString
7054
}
7055
7056
PyObject *
7057
PyUnicode_AsASCIIString(PyObject *unicode)
7058
{
7059
    return _PyUnicode_AsASCIIString(unicode, NULL);
inline
           
_PyUnicode_AsASCIIString can be inlined into PyUnicode_AsASCIIString with cost=205 (threshold=250) 
PyUnicode_AsASCIIString
inline
           
_PyUnicode_AsASCIIString inlined into PyUnicode_AsASCIIString 
PyUnicode_AsASCIIString
7060
}
7061
7062
#ifdef MS_WINDOWS
7063
7064
/* --- MBCS codecs for Windows -------------------------------------------- */
7065
7066
#if SIZEOF_INT < SIZEOF_SIZE_T
7067
#define NEED_RETRY
7068
#endif
7069
7070
#ifndef WC_ERR_INVALID_CHARS
7071
#  define WC_ERR_INVALID_CHARS 0x0080
7072
#endif
7073
7074
static const char*
7075
code_page_name(UINT code_page, PyObject **obj)
7076
{
7077
    *obj = NULL;
7078
    if (code_page == CP_ACP)
7079
        return "mbcs";
7080
    if (code_page == CP_UTF7)
7081
        return "CP_UTF7";
7082
    if (code_page == CP_UTF8)
7083
        return "CP_UTF8";
7084
7085
    *obj = PyBytes_FromFormat("cp%u", code_page);
7086
    if (*obj == NULL)
7087
        return NULL;
7088
    return PyBytes_AS_STRING(*obj);
7089
}
7090
7091
static DWORD
7092
decode_code_page_flags(UINT code_page)
7093
{
7094
    if (code_page == CP_UTF7) {
7095
        /* The CP_UTF7 decoder only supports flags=0 */
7096
        return 0;
7097
    }
7098
    else
7099
        return MB_ERR_INVALID_CHARS;
7100
}
7101
7102
/*
7103
 * Decode a byte string from a Windows code page into unicode object in strict
7104
 * mode.
7105
 *
7106
 * Returns consumed size if succeed, returns -2 on decode error, or raise an
7107
 * OSError and returns -1 on other error.
7108
 */
7109
static int
7110
decode_code_page_strict(UINT code_page,
7111
                        PyObject **v,
7112
                        const char *in,
7113
                        int insize)
7114
{
7115
    const DWORD flags = decode_code_page_flags(code_page);
7116
    wchar_t *out;
7117
    DWORD outsize;
7118
7119
    /* First get the size of the result */
7120
    assert(insize > 0);
7121
    outsize = MultiByteToWideChar(code_page, flags, in, insize, NULL, 0);
7122
    if (outsize <= 0)
7123
        goto error;
7124
7125
    if (*v == NULL) {
7126
        /* Create unicode object */
7127
        /* FIXME: don't use _PyUnicode_New(), but allocate a wchar_t* buffer */
7128
        *v = (PyObject*)_PyUnicode_New(outsize);
7129
        if (*v == NULL)
7130
            return -1;
7131
        out = PyUnicode_AS_UNICODE(*v);
7132
    }
7133
    else {
7134
        /* Extend unicode object */
7135
        Py_ssize_t n = PyUnicode_GET_SIZE(*v);
7136
        if (unicode_resize(v, n + outsize) < 0)
7137
            return -1;
7138
        out = PyUnicode_AS_UNICODE(*v) + n;
7139
    }
7140
7141
    /* Do the conversion */
7142
    outsize = MultiByteToWideChar(code_page, flags, in, insize, out, outsize);
7143
    if (outsize <= 0)
7144
        goto error;
7145
    return insize;
7146
7147
error:
7148
    if (GetLastError() == ERROR_NO_UNICODE_TRANSLATION)
7149
        return -2;
7150
    PyErr_SetFromWindowsErr(0);
7151
    return -1;
7152
}
7153
7154
/*
7155
 * Decode a byte string from a code page into unicode object with an error
7156
 * handler.
7157
 *
7158
 * Returns consumed size if succeed, or raise an OSError or
7159
 * UnicodeDecodeError exception and returns -1 on error.
7160
 */
7161
static int
7162
decode_code_page_errors(UINT code_page,
7163
                        PyObject **v,
7164
                        const char *in, const int size,
7165
                        const char *errors, int final)
7166
{
7167
    const char *startin = in;
7168
    const char *endin = in + size;
7169
    const DWORD flags = decode_code_page_flags(code_page);
7170
    /* Ideally, we should get reason from FormatMessage. This is the Windows
7171
       2000 English version of the message. */
7172
    const char *reason = "No mapping for the Unicode character exists "
7173
                         "in the target code page.";
7174
    /* each step cannot decode more than 1 character, but a character can be
7175
       represented as a surrogate pair */
7176
    wchar_t buffer[2], *startout, *out;
7177
    int insize;
7178
    Py_ssize_t outsize;
7179
    PyObject *errorHandler = NULL;
7180
    PyObject *exc = NULL;
7181
    PyObject *encoding_obj = NULL;
7182
    const char *encoding;
7183
    DWORD err;
7184
    int ret = -1;
7185
7186
    assert(size > 0);
7187
7188
    encoding = code_page_name(code_page, &encoding_obj);
7189
    if (encoding == NULL)
7190
        return -1;
7191
7192
    if ((errors == NULL || strcmp(errors, "strict") == 0) && final) {
7193
        /* The last error was ERROR_NO_UNICODE_TRANSLATION, then we raise a
7194
           UnicodeDecodeError. */
7195
        make_decode_exception(&exc, encoding, in, size, 0, 0, reason);
7196
        if (exc != NULL) {
7197
            PyCodec_StrictErrors(exc);
7198
            Py_CLEAR(exc);
7199
        }
7200
        goto error;
7201
    }
7202
7203
    if (*v == NULL) {
7204
        /* Create unicode object */
7205
        if (size > PY_SSIZE_T_MAX / (Py_ssize_t)Py_ARRAY_LENGTH(buffer)) {
7206
            PyErr_NoMemory();
7207
            goto error;
7208
        }
7209
        /* FIXME: don't use _PyUnicode_New(), but allocate a wchar_t* buffer */
7210
        *v = (PyObject*)_PyUnicode_New(size * Py_ARRAY_LENGTH(buffer));
7211
        if (*v == NULL)
7212
            goto error;
7213
        startout = PyUnicode_AS_UNICODE(*v);
7214
    }
7215
    else {
7216
        /* Extend unicode object */
7217
        Py_ssize_t n = PyUnicode_GET_SIZE(*v);
7218
        if (size > (PY_SSIZE_T_MAX - n) / (Py_ssize_t)Py_ARRAY_LENGTH(buffer)) {
7219
            PyErr_NoMemory();
7220
            goto error;
7221
        }
7222
        if (unicode_resize(v, n + size * Py_ARRAY_LENGTH(buffer)) < 0)
7223
            goto error;
7224
        startout = PyUnicode_AS_UNICODE(*v) + n;
7225
    }
7226
7227
    /* Decode the byte string character per character */
7228
    out = startout;
7229
    while (in < endin)
7230
    {
7231
        /* Decode a character */
7232
        insize = 1;
7233
        do
7234
        {
7235
            outsize = MultiByteToWideChar(code_page, flags,
7236
                                          in, insize,
7237
                                          buffer, Py_ARRAY_LENGTH(buffer));
7238
            if (outsize > 0)
7239
                break;
7240
            err = GetLastError();
7241
            if (err != ERROR_NO_UNICODE_TRANSLATION
7242
                && err != ERROR_INSUFFICIENT_BUFFER)
7243
            {
7244
                PyErr_SetFromWindowsErr(0);
7245
                goto error;
7246
            }
7247
            insize++;
7248
        }
7249
        /* 4=maximum length of a UTF-8 sequence */
7250
        while (insize <= 4 && (in + insize) <= endin);
7251
7252
        if (outsize <= 0) {
7253
            Py_ssize_t startinpos, endinpos, outpos;
7254
7255
            /* last character in partial decode? */
7256
            if (in + insize >= endin && !final)
7257
                break;
7258
7259
            startinpos = in - startin;
7260
            endinpos = startinpos + 1;
7261
            outpos = out - PyUnicode_AS_UNICODE(*v);
7262
            if (unicode_decode_call_errorhandler_wchar(
7263
                    errors, &errorHandler,
7264
                    encoding, reason,
7265
                    &startin, &endin, &startinpos, &endinpos, &exc, &in,
7266
                    v, &outpos))
7267
            {
7268
                goto error;
7269
            }
7270
            out = PyUnicode_AS_UNICODE(*v) + outpos;
7271
        }
7272
        else {
7273
            in += insize;
7274
            memcpy(out, buffer, outsize * sizeof(wchar_t));
7275
            out += outsize;
7276
        }
7277
    }
7278
7279
    /* write a NUL character at the end */
7280
    *out = 0;
7281
7282
    /* Extend unicode object */
7283
    outsize = out - startout;
7284
    assert(outsize <= PyUnicode_WSTR_LENGTH(*v));
7285
    if (unicode_resize(v, outsize) < 0)
7286
        goto error;
7287
    /* (in - startin) <= size and size is an int */
7288
    ret = Py_SAFE_DOWNCAST(in - startin, Py_ssize_t, int);
7289
7290
error:
7291
    Py_XDECREF(encoding_obj);
7292
    Py_XDECREF(errorHandler);
7293
    Py_XDECREF(exc);
7294
    return ret;
7295
}
7296
7297
static PyObject *
7298
decode_code_page_stateful(int code_page,
7299
                          const char *s, Py_ssize_t size,
7300
                          const char *errors, Py_ssize_t *consumed)
7301
{
7302
    PyObject *v = NULL;
7303
    int chunk_size, final, converted, done;
7304
7305
    if (code_page < 0) {
7306
        PyErr_SetString(PyExc_ValueError, "invalid code page number");
7307
        return NULL;
7308
    }
7309
7310
    if (consumed)
7311
        *consumed = 0;
7312
7313
    do
7314
    {
7315
#ifdef NEED_RETRY
7316
        if (size > INT_MAX) {
7317
            chunk_size = INT_MAX;
7318
            final = 0;
7319
            done = 0;
7320
        }
7321
        else
7322
#endif
7323
        {
7324
            chunk_size = (int)size;
7325
            final = (consumed == NULL);
7326
            done = 1;
7327
        }
7328
7329
        if (chunk_size == 0 && done) {
7330
            if (v != NULL)
7331
                break;
7332
            _Py_RETURN_UNICODE_EMPTY();
7333
        }
7334
7335
        converted = decode_code_page_strict(code_page, &v,
7336
                                            s, chunk_size);
7337
        if (converted == -2)
7338
            converted = decode_code_page_errors(code_page, &v,
7339
                                                s, chunk_size,
7340
                                                errors, final);
7341
        assert(converted != 0 || done);
7342
7343
        if (converted < 0) {
7344
            Py_XDECREF(v);
7345
            return NULL;
7346
        }
7347
7348
        if (consumed)
7349
            *consumed += converted;
7350
7351
        s += converted;
7352
        size -= converted;
7353
    } while (!done);
7354
7355
    return unicode_result(v);
7356
}
7357
7358
PyObject *
7359
PyUnicode_DecodeCodePageStateful(int code_page,
7360
                                 const char *s,
7361
                                 Py_ssize_t size,
7362
                                 const char *errors,
7363
                                 Py_ssize_t *consumed)
7364
{
7365
    return decode_code_page_stateful(code_page, s, size, errors, consumed);
7366
}
7367
7368
PyObject *
7369
PyUnicode_DecodeMBCSStateful(const char *s,
7370
                             Py_ssize_t size,
7371
                             const char *errors,
7372
                             Py_ssize_t *consumed)
7373
{
7374
    return decode_code_page_stateful(CP_ACP, s, size, errors, consumed);
7375
}
7376
7377
PyObject *
7378
PyUnicode_DecodeMBCS(const char *s,
7379
                     Py_ssize_t size,
7380
                     const char *errors)
7381
{
7382
    return PyUnicode_DecodeMBCSStateful(s, size, errors, NULL);
7383
}
7384
7385
static DWORD
7386
encode_code_page_flags(UINT code_page, const char *errors)
7387
{
7388
    if (code_page == CP_UTF8) {
7389
        return WC_ERR_INVALID_CHARS;
7390
    }
7391
    else if (code_page == CP_UTF7) {
7392
        /* CP_UTF7 only supports flags=0 */
7393
        return 0;
7394
    }
7395
    else {
7396
        if (errors != NULL && strcmp(errors, "replace") == 0)
7397
            return 0;
7398
        else
7399
            return WC_NO_BEST_FIT_CHARS;
7400
    }
7401
}
7402
7403
/*
7404
 * Encode a Unicode string to a Windows code page into a byte string in strict
7405
 * mode.
7406
 *
7407
 * Returns consumed characters if succeed, returns -2 on encode error, or raise
7408
 * an OSError and returns -1 on other error.
7409
 */
7410
static int
7411
encode_code_page_strict(UINT code_page, PyObject **outbytes,
7412
                        PyObject *unicode, Py_ssize_t offset, int len,
7413
                        const char* errors)
7414
{
7415
    BOOL usedDefaultChar = FALSE;
7416
    BOOL *pusedDefaultChar = &usedDefaultChar;
7417
    int outsize;
7418
    wchar_t *p;
7419
    Py_ssize_t size;
7420
    const DWORD flags = encode_code_page_flags(code_page, NULL);
7421
    char *out;
7422
    /* Create a substring so that we can get the UTF-16 representation
7423
       of just the slice under consideration. */
7424
    PyObject *substring;
7425
7426
    assert(len > 0);
7427
7428
    if (code_page != CP_UTF8 && code_page != CP_UTF7)
7429
        pusedDefaultChar = &usedDefaultChar;
7430
    else
7431
        pusedDefaultChar = NULL;
7432
7433
    substring = PyUnicode_Substring(unicode, offset, offset+len);
7434
    if (substring == NULL)
7435
        return -1;
7436
    p = PyUnicode_AsUnicodeAndSize(substring, &size);
7437
    if (p == NULL) {
7438
        Py_DECREF(substring);
7439
        return -1;
7440
    }
7441
    assert(size <= INT_MAX);
7442
7443
    /* First get the size of the result */
7444
    outsize = WideCharToMultiByte(code_page, flags,
7445
                                  p, (int)size,
7446
                                  NULL, 0,
7447
                                  NULL, pusedDefaultChar);
7448
    if (outsize <= 0)
7449
        goto error;
7450
    /* If we used a default char, then we failed! */
7451
    if (pusedDefaultChar && *pusedDefaultChar) {
7452
        Py_DECREF(substring);
7453
        return -2;
7454
    }
7455
7456
    if (*outbytes == NULL) {
7457
        /* Create string object */
7458
        *outbytes = PyBytes_FromStringAndSize(NULL, outsize);
7459
        if (*outbytes == NULL) {
7460
            Py_DECREF(substring);
7461
            return -1;
7462
        }
7463
        out = PyBytes_AS_STRING(*outbytes);
7464
    }
7465
    else {
7466
        /* Extend string object */
7467
        const Py_ssize_t n = PyBytes_Size(*outbytes);
7468
        if (outsize > PY_SSIZE_T_MAX - n) {
7469
            PyErr_NoMemory();
7470
            Py_DECREF(substring);
7471
            return -1;
7472
        }
7473
        if (_PyBytes_Resize(outbytes, n + outsize) < 0) {
7474
            Py_DECREF(substring);
7475
            return -1;
7476
        }
7477
        out = PyBytes_AS_STRING(*outbytes) + n;
7478
    }
7479
7480
    /* Do the conversion */
7481
    outsize = WideCharToMultiByte(code_page, flags,
7482
                                  p, (int)size,
7483
                                  out, outsize,
7484
                                  NULL, pusedDefaultChar);
7485
    Py_CLEAR(substring);
7486
    if (outsize <= 0)
7487
        goto error;
7488
    if (pusedDefaultChar && *pusedDefaultChar)
7489
        return -2;
7490
    return 0;
7491
7492
error:
7493
    Py_XDECREF(substring);
7494
    if (GetLastError() == ERROR_NO_UNICODE_TRANSLATION)
7495
        return -2;
7496
    PyErr_SetFromWindowsErr(0);
7497
    return -1;
7498
}
7499
7500
/*
7501
 * Encode a Unicode string to a Windows code page into a byte string using an
7502
 * error handler.
7503
 *
7504
 * Returns consumed characters if succeed, or raise an OSError and returns
7505
 * -1 on other error.
7506
 */
7507
static int
7508
encode_code_page_errors(UINT code_page, PyObject **outbytes,
7509
                        PyObject *unicode, Py_ssize_t unicode_offset,
7510
                        Py_ssize_t insize, const char* errors)
7511
{
7512
    const DWORD flags = encode_code_page_flags(code_page, errors);
7513
    Py_ssize_t pos = unicode_offset;
7514
    Py_ssize_t endin = unicode_offset + insize;
7515
    /* Ideally, we should get reason from FormatMessage. This is the Windows
7516
       2000 English version of the message. */
7517
    const char *reason = "invalid character";
7518
    /* 4=maximum length of a UTF-8 sequence */
7519
    char buffer[4];
7520
    BOOL usedDefaultChar = FALSE, *pusedDefaultChar;
7521
    Py_ssize_t outsize;
7522
    char *out;
7523
    PyObject *errorHandler = NULL;
7524
    PyObject *exc = NULL;
7525
    PyObject *encoding_obj = NULL;
7526
    const char *encoding;
7527
    Py_ssize_t newpos, newoutsize;
7528
    PyObject *rep;
7529
    int ret = -1;
7530
7531
    assert(insize > 0);
7532
7533
    encoding = code_page_name(code_page, &encoding_obj);
7534
    if (encoding == NULL)
7535
        return -1;
7536
7537
    if (errors == NULL || strcmp(errors, "strict") == 0) {
7538
        /* The last error was ERROR_NO_UNICODE_TRANSLATION,
7539
           then we raise a UnicodeEncodeError. */
7540
        make_encode_exception(&exc, encoding, unicode, 0, 0, reason);
7541
        if (exc != NULL) {
7542
            PyCodec_StrictErrors(exc);
7543
            Py_DECREF(exc);
7544
        }
7545
        Py_XDECREF(encoding_obj);
7546
        return -1;
7547
    }
7548
7549
    if (code_page != CP_UTF8 && code_page != CP_UTF7)
7550
        pusedDefaultChar = &usedDefaultChar;
7551
    else
7552
        pusedDefaultChar = NULL;
7553
7554
    if (Py_ARRAY_LENGTH(buffer) > PY_SSIZE_T_MAX / insize) {
7555
        PyErr_NoMemory();
7556
        goto error;
7557
    }
7558
    outsize = insize * Py_ARRAY_LENGTH(buffer);
7559
7560
    if (*outbytes == NULL) {
7561
        /* Create string object */
7562
        *outbytes = PyBytes_FromStringAndSize(NULL, outsize);
7563
        if (*outbytes == NULL)
7564
            goto error;
7565
        out = PyBytes_AS_STRING(*outbytes);
7566
    }
7567
    else {
7568
        /* Extend string object */
7569
        Py_ssize_t n = PyBytes_Size(*outbytes);
7570
        if (n > PY_SSIZE_T_MAX - outsize) {
7571
            PyErr_NoMemory();
7572
            goto error;
7573
        }
7574
        if (_PyBytes_Resize(outbytes, n + outsize) < 0)
7575
            goto error;
7576
        out = PyBytes_AS_STRING(*outbytes) + n;
7577
    }
7578
7579
    /* Encode the string character per character */
7580
    while (pos < endin)
7581
    {
7582
        Py_UCS4 ch = PyUnicode_READ_CHAR(unicode, pos);
7583
        wchar_t chars[2];
7584
        int charsize;
7585
        if (ch < 0x10000) {
7586
            chars[0] = (wchar_t)ch;
7587
            charsize = 1;
7588
        }
7589
        else {
7590
            chars[0] = Py_UNICODE_HIGH_SURROGATE(ch);
7591
            chars[1] = Py_UNICODE_LOW_SURROGATE(ch);
7592
            charsize = 2;
7593
        }
7594
7595
        outsize = WideCharToMultiByte(code_page, flags,
7596
                                      chars, charsize,
7597
                                      buffer, Py_ARRAY_LENGTH(buffer),
7598
                                      NULL, pusedDefaultChar);
7599
        if (outsize > 0) {
7600
            if (pusedDefaultChar == NULL || !(*pusedDefaultChar))
7601
            {
7602
                pos++;
7603
                memcpy(out, buffer, outsize);
7604
                out += outsize;
7605
                continue;
7606
            }
7607
        }
7608
        else if (GetLastError() != ERROR_NO_UNICODE_TRANSLATION) {
7609
            PyErr_SetFromWindowsErr(0);
7610
            goto error;
7611
        }
7612
7613
        rep = unicode_encode_call_errorhandler(
7614
                  errors, &errorHandler, encoding, reason,
7615
                  unicode, &exc,
7616
                  pos, pos + 1, &newpos);
7617
        if (rep == NULL)
7618
            goto error;
7619
        pos = newpos;
7620
7621
        if (PyBytes_Check(rep)) {
7622
            outsize = PyBytes_GET_SIZE(rep);
7623
            if (outsize != 1) {
7624
                Py_ssize_t offset = out - PyBytes_AS_STRING(*outbytes);
7625
                newoutsize = PyBytes_GET_SIZE(*outbytes) + (outsize - 1);
7626
                if (_PyBytes_Resize(outbytes, newoutsize) < 0) {
7627
                    Py_DECREF(rep);
7628
                    goto error;
7629
                }
7630
                out = PyBytes_AS_STRING(*outbytes) + offset;
7631
            }
7632
            memcpy(out, PyBytes_AS_STRING(rep), outsize);
7633
            out += outsize;
7634
        }
7635
        else {
7636
            Py_ssize_t i;
7637
            enum PyUnicode_Kind kind;
7638
            void *data;
7639
7640
            if (PyUnicode_READY(rep) == -1) {
7641
                Py_DECREF(rep);
7642
                goto error;
7643
            }
7644
7645
            outsize = PyUnicode_GET_LENGTH(rep);
7646
            if (outsize != 1) {
7647
                Py_ssize_t offset = out - PyBytes_AS_STRING(*outbytes);
7648
                newoutsize = PyBytes_GET_SIZE(*outbytes) + (outsize - 1);
7649
                if (_PyBytes_Resize(outbytes, newoutsize) < 0) {
7650
                    Py_DECREF(rep);
7651
                    goto error;
7652
                }
7653
                out = PyBytes_AS_STRING(*outbytes) + offset;
7654
            }
7655
            kind = PyUnicode_KIND(rep);
7656
            data = PyUnicode_DATA(rep);
7657
            for (i=0; i < outsize; i++) {
7658
                Py_UCS4 ch = PyUnicode_READ(kind, data, i);
7659
                if (ch > 127) {
7660
                    raise_encode_exception(&exc,
7661
                        encoding, unicode,
7662
                        pos, pos + 1,
7663
                        "unable to encode error handler result to ASCII");
7664
                    Py_DECREF(rep);
7665
                    goto error;
7666
                }
7667
                *out = (unsigned char)ch;
7668
                out++;
7669
            }
7670
        }
7671
        Py_DECREF(rep);
7672
    }
7673
    /* write a NUL byte */
7674
    *out = 0;
7675
    outsize = out - PyBytes_AS_STRING(*outbytes);
7676
    assert(outsize <= PyBytes_GET_SIZE(*outbytes));
7677
    if (_PyBytes_Resize(outbytes, outsize) < 0)
7678
        goto error;
7679
    ret = 0;
7680
7681
error:
7682
    Py_XDECREF(encoding_obj);
7683
    Py_XDECREF(errorHandler);
7684
    Py_XDECREF(exc);
7685
    return ret;
7686
}
7687
7688
static PyObject *
7689
encode_code_page(int code_page,
7690
                 PyObject *unicode,
7691
                 const char *errors)
7692
{
7693
    Py_ssize_t len;
7694
    PyObject *outbytes = NULL;
7695
    Py_ssize_t offset;
7696
    int chunk_len, ret, done;
7697
7698
    if (!PyUnicode_Check(unicode)) {
7699
        PyErr_BadArgument();
7700
        return NULL;
7701
    }
7702
7703
    if (PyUnicode_READY(unicode) == -1)
7704
        return NULL;
7705
    len = PyUnicode_GET_LENGTH(unicode);
7706
7707
    if (code_page < 0) {
7708
        PyErr_SetString(PyExc_ValueError, "invalid code page number");
7709
        return NULL;
7710
    }
7711
7712
    if (len == 0)
7713
        return PyBytes_FromStringAndSize(NULL, 0);
7714
7715
    offset = 0;
7716
    do
7717
    {
7718
#ifdef NEED_RETRY
7719
        /* UTF-16 encoding may double the size, so use only INT_MAX/2
7720
           chunks. */
7721
        if (len > INT_MAX/2) {
7722
            chunk_len = INT_MAX/2;
7723
            done = 0;
7724
        }
7725
        else
7726
#endif
7727
        {
7728
            chunk_len = (int)len;
7729
            done = 1;
7730
        }
7731
7732
        ret = encode_code_page_strict(code_page, &outbytes,
7733
                                      unicode, offset, chunk_len,
7734
                                      errors);
7735
        if (ret == -2)
7736
            ret = encode_code_page_errors(code_page, &outbytes,
7737
                                          unicode, offset,
7738
                                          chunk_len, errors);
7739
        if (ret < 0) {
7740
            Py_XDECREF(outbytes);
7741
            return NULL;
7742
        }
7743
7744
        offset += chunk_len;
7745
        len -= chunk_len;
7746
    } while (!done);
7747
7748
    return outbytes;
7749
}
7750
7751
PyObject *
7752
PyUnicode_EncodeMBCS(const Py_UNICODE *p,
7753
                     Py_ssize_t size,
7754
                     const char *errors)
7755
{
7756
    PyObject *unicode, *res;
7757
    unicode = PyUnicode_FromUnicode(p, size);
7758
    if (unicode == NULL)
7759
        return NULL;
7760
    res = encode_code_page(CP_ACP, unicode, errors);
7761
    Py_DECREF(unicode);
7762
    return res;
7763
}
7764
7765
PyObject *
7766
PyUnicode_EncodeCodePage(int code_page,
7767
                         PyObject *unicode,
7768
                         const char *errors)
7769
{
7770
    return encode_code_page(code_page, unicode, errors);
7771
}
7772
7773
PyObject *
7774
PyUnicode_AsMBCSString(PyObject *unicode)
7775
{
7776
    return PyUnicode_EncodeCodePage(CP_ACP, unicode, NULL);
7777
}
7778
7779
#undef NEED_RETRY
7780
7781
#endif /* MS_WINDOWS */
7782
7783
/* --- Character Mapping Codec -------------------------------------------- */
7784
7785
static int
7786
charmap_decode_string(const char *s,
7787
                      Py_ssize_t size,
7788
                      PyObject *mapping,
7789
                      const char *errors,
7790
                      _PyUnicodeWriter *writer)
7791
{
7792
    const char *starts = s;
7793
    const char *e;
7794
    Py_ssize_t startinpos, endinpos;
7795
    PyObject *errorHandler = NULL, *exc = NULL;
7796
    Py_ssize_t maplen;
7797
    enum PyUnicode_Kind mapkind;
7798
    void *mapdata;
7799
    Py_UCS4 x;
7800
    unsigned char ch;
7801
7802
    if (PyUnicode_READY(mapping) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
charmap_decode_string
inline
        
_PyUnicode_Ready will not be inlined into charmap_decode_string 
charmap_decode_string
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeCharmap
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7803
        return -1;
7804
7805
    maplen = PyUnicode_GET_LENGTH(mapping);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7806
    mapdata = PyUnicode_DATA(mapping);
gvn
              
load of type i32 not eliminated in favor of load because it is clobbered by call 
charmap_decode_string
gvn
              
load eliminated by PRE 
charmap_decode_string
gvn
              
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_string
gvn
              
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
              
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7807
    mapkind = PyUnicode_KIND(mapping);
7808
7809
    e = s + size;
gvn
        
load of type i8* eliminated in favor of  
charmap_decode_string
7810
7811
    if (mapkind == PyUnicode_1BYTE_KIND && maplen >= 256) {
7812
        /* fast-path for cp037, cp500 and iso8859_1 encodings. iso8859_1
7813
         * is disabled in encoding aliases, latin1 is preferred because
7814
         * its implementation is faster. */
7815
        Py_UCS1 *mapdata_ucs1 = (Py_UCS1 *)mapdata;
7816
        Py_UCS1 *outdata = (Py_UCS1 *)writer->data;
gvn
                                              
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                                              
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7817
        Py_UCS4 maxchar = writer->maxchar;
gvn
                                  
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                                  
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7818
7819
        assert (writer->kind == PyUnicode_1BYTE_KIND);
7820
        while (s < e) {
licm
               
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
               
load of type i8* eliminated in favor of  
charmap_decode_string
gvn
                   
load of type i8* eliminated in favor of getelementptr 
charmap_decode_string
gvn
                   
load of type i8* not eliminated in favor of store because it is clobbered by store 
charmap_decode_string
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                   
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeCharmap
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeCharmap
loop-vectorize
        
loop not vectorized 
PyUnicode_DecodeCharmap
7821
            ch = *s;
gvn
                 
load of type i8 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                 
load of type i8 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
                 
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
                 
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                 
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7822
            x = mapdata_ucs1[ch];
7823
            if (x > maxchar) {
7824
                if (_PyUnicodeWriter_Prepare(writer, 1, 0xff) == -1)
inline
                    
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
charmap_decode_string
inline
                    
_PyUnicodeWriter_PrepareInternal will not be inlined into charmap_decode_string 
charmap_decode_string
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
licm
                    
hosting getelementptr 
charmap_decode_string
gvn
                    
load of type i32 not eliminated in favor of load because it is clobbered by store 
charmap_decode_string
gvn
                    
load of type i64 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_string
inline
                    
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeCharmap
inline
                    
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                    
load of type i32 not eliminated in favor of load because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                    
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
7825
                    goto onError;
7826
                maxchar = writer->maxchar;
licm
                                  
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                                  
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                                  
load eliminated by PRE 
charmap_decode_string
7827
                outdata = (Py_UCS1 *)writer->data;
licm
                                             
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                                             
load of type i8* not eliminated in favor of load because it is clobbered by store 
charmap_decode_string
gvn
                                             
load of type i8* not eliminated in favor of load because it is clobbered by call 
charmap_decode_string
licm
                                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                                             
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
                                             
load of type i8* not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeCharmap
7828
            }
7829
            outdata[writer->pos] = x;
licm
                            
hosting getelementptr 
charmap_decode_string
licm
                            
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_string
licm
                            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7830
            writer->pos++;
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                       
load of type i64 not eliminated in favor of load because it is clobbered by store 
charmap_decode_string
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                       
load of type i64 not eliminated in favor of load because it is clobbered by store 
PyUnicode_DecodeCharmap
7831
            ++s;
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by store 
charmap_decode_string
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeCharmap
7832
        }
7833
        return 0;
7834
    }
7835
7836
    while (s < e) {
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
licm
               
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
           
load of type i8* eliminated in favor of  
charmap_decode_string
gvn
               
load of type i8* eliminated in favor of getelementptr 
charmap_decode_string
gvn
           
load of type i8* not eliminated in favor of store because it is clobbered by call 
charmap_decode_string
gvn
           
load eliminated by PRE 
charmap_decode_string
gvn
               
load of type i8* not eliminated in favor of store because it is clobbered by call 
charmap_decode_string
gvn
               
load eliminated by PRE 
charmap_decode_string
7837
        if (mapkind == PyUnicode_2BYTE_KIND && maplen >= 256) {
licm
                    
hosting icmp 
charmap_decode_string
licm
                                            
hosting and 
charmap_decode_string
7838
            enum PyUnicode_Kind outkind = writer->kind;
licm
                                                  
hosting getelementptr 
charmap_decode_string
licm
                                                  
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                                                  
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                                                  
load of type i32 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
                                                  
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_string
licm
                                                  
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                                                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeCharmap
7839
            Py_UCS2 *mapdata_ucs2 = (Py_UCS2 *)mapdata;
licm
                                    
hosting bitcast 
charmap_decode_string
7840
            if (outkind == PyUnicode_1BYTE_KIND) {
7841
                Py_UCS1 *outdata = (Py_UCS1 *)writer->data;
licm
                                                      
hosting getelementptr 
charmap_decode_string
licm
                                                      
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                                                      
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                                                      
load of type i8* not eliminated because it is clobbered by store 
charmap_decode_string
gvn
                                                      
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_string
licm
                                                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                                                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                                      
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
7842
                Py_UCS4 maxchar = writer->maxchar;
licm
                                          
hosting getelementptr 
charmap_decode_string
licm
                                          
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                                          
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                                          
load of type i32 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
                                          
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                                          
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_string
licm
                                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                                          
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                          
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                          
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
                                          
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7843
                while (s < e) {
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
licm
                           
hosting load 
charmap_decode_string
licm
                           
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                       
load of type i8* eliminated in favor of phi 
charmap_decode_string
gvn
                           
load of type i8* eliminated in favor of phi 
charmap_decode_string
loop-vectorize
                
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeCharmap
loop-vectorize
                
loop not vectorized 
PyUnicode_DecodeCharmap
7844
                    ch = *s;
gvn
                         
load of type i8 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                         
load of type i8 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
                         
load of type i8 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
                         
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
                         
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                         
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                         
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
7845
                    x = mapdata_ucs2[ch];
7846
                    if (x > maxchar)
7847
                        goto Error;
7848
                    outdata[writer->pos] = x;
licm
                                    
hosting getelementptr 
charmap_decode_string
licm
                                    
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                                    
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                                    
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_string
licm
                                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7849
                    writer->pos++;
licm
                               
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                               
load of type i64 not eliminated in favor of load because it is clobbered by store 
charmap_decode_string
licm
                               
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                               
load of type i64 not eliminated in favor of load because it is clobbered by store 
PyUnicode_DecodeCharmap
7850
                    ++s;
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
licm
                    
Moving accesses to memory location out of the loop 
charmap_decode_string
gvn
                    
load of type i8* eliminated in favor of phi 
charmap_decode_string
7851
                }
7852
                break;
7853
            }
7854
            else if (outkind == PyUnicode_2BYTE_KIND) {
7855
                Py_UCS2 *outdata = (Py_UCS2 *)writer->data;
licm
                                                      
hosting getelementptr 
charmap_decode_string
licm
                                                      
hosting bitcast 
charmap_decode_string
licm
                                                      
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                                                      
load of type i16* not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                                                      
load of type i16* not eliminated because it is clobbered by store 
charmap_decode_string
gvn
                                                      
load of type i16* not eliminated because it is clobbered by call 
charmap_decode_string
licm
                                                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                                                      
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                                      
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                                      
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
7856
                while (s < e) {
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
licm
                           
hosting load 
charmap_decode_string
licm
                           
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                       
load of type i8* eliminated in favor of phi 
charmap_decode_string
gvn
                           
load of type i8* eliminated in favor of phi 
charmap_decode_string
loop-vectorize
                
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeCharmap
loop-vectorize
                
loop not vectorized 
PyUnicode_DecodeCharmap
7857
                    ch = *s;
gvn
                         
load of type i8 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                         
load of type i8 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
                         
load of type i8 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
                         
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
                         
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                         
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                         
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
7858
                    x = mapdata_ucs2[ch];
licm
                        
sinking zext 
charmap_decode_string
7859
                    if (x == 0xFFFE)
7860
                        goto Error;
7861
                    outdata[writer->pos] = x;
licm
                                    
hosting getelementptr 
charmap_decode_string
licm
                                    
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                                    
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
                                    
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_string
licm
                                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7862
                    writer->pos++;
7863
                    ++s;
licm
                    
Moving accesses to memory location out of the loop 
charmap_decode_string
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                    
load of type i8* eliminated in favor of phi 
charmap_decode_string
7864
                }
7865
                break;
7866
            }
7867
        }
7868
        ch = *s;
licm
              
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
              
load of type i8* eliminated in favor of phi 
charmap_decode_string
gvn
             
load of type i8 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
             
load of type i8 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
             
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
             
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
             
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7869
7870
        if (ch < maplen)
7871
            x = PyUnicode_READ(mapkind, mapdata, ch);
licm
                
hosting bitcast 
charmap_decode_string
7872
        else
7873
            x = 0xfffe; /* invalid value */
7874
Error:
7875
        if (x == 0xfffe)
7876
        {
7877
            /* undefined mapping */
7878
            startinpos = s-starts;
licm
                         
hosting bitcast 
charmap_decode_string
licm
                         
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
licm
                           
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
                         
load of type i64 eliminated in favor of phi 
charmap_decode_string
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
charmap_decode_string
licm
                           
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
7879
            endinpos = startinpos+1;
7880
            if (unicode_decode_call_errorhandler_writer(
inline
                
unicode_decode_call_errorhandler_writer too costly to inline (cost=630, threshold=625) 
charmap_decode_string
inline
                
unicode_decode_call_errorhandler_writer will not be inlined into charmap_decode_string 
charmap_decode_string
inline
                
unicode_decode_call_errorhandler_writer too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeCharmap
inline
                
unicode_decode_call_errorhandler_writer will not be inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
7881
                    errors, &errorHandler,
7882
                    "charmap", "character maps to <undefined>",
7883
                    &starts, &e, &startinpos, &endinpos, &exc, &s,
7884
                    writer)) {
7885
                goto onError;
7886
            }
7887
            continue;
7888
        }
7889
7890
        if (_PyUnicodeWriter_WriteCharInline(writer, x) < 0)
inline
            
_PyUnicodeWriter_WriteCharInline can be inlined into charmap_decode_string with cost=150 (threshold=325) 
charmap_decode_string
inline
            
_PyUnicodeWriter_WriteCharInline inlined into charmap_decode_string 
charmap_decode_string
7891
            goto onError;
7892
        ++s;
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
        
load of type i8* eliminated in favor of phi 
charmap_decode_string
7893
    }
7894
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
charmap_decode_string
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
7895
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
charmap_decode_string
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
7896
    return 0;
7897
7898
onError:
7899
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
charmap_decode_string
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
charmap_decode_string
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
7900
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
charmap_decode_string
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
charmap_decode_string
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
7901
    return -1;
7902
}
7903
7904
static int
7905
charmap_decode_mapping(const char *s,
7906
                       Py_ssize_t size,
7907
                       PyObject *mapping,
7908
                       const char *errors,
7909
                       _PyUnicodeWriter *writer)
7910
{
7911
    const char *starts = s;
7912
    const char *e;
7913
    Py_ssize_t startinpos, endinpos;
7914
    PyObject *errorHandler = NULL, *exc = NULL;
7915
    unsigned char ch;
7916
    PyObject *key, *item = NULL;
7917
7918
    e = s + size;
gvn
        
load of type i8* eliminated in favor of  
charmap_decode_mapping
7919
7920
    while (s < e) {
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_mapping
licm
               
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_mapping
gvn
           
load of type i8* not eliminated in favor of store because it is clobbered by call 
charmap_decode_mapping
gvn
           
load eliminated by PRE 
charmap_decode_mapping
gvn
               
load of type i8* not eliminated in favor of store because it is clobbered by call 
charmap_decode_mapping
gvn
               
load eliminated by PRE 
charmap_decode_mapping
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_DecodeCharmap
loop-vectorize
    
loop not vectorized 
PyUnicode_DecodeCharmap
7921
        ch = *s;
gvn
             
load of type i8 not eliminated because it is clobbered by store 
charmap_decode_mapping
gvn
             
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
             
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7922
7923
        /* Get mapping (char ordinal -> integer, Unicode char or None) */
7924
        key = PyLong_FromLong((long)ch);
inline
              
PyLong_FromLong will not be inlined into charmap_decode_mapping because its definition is unavailable 
charmap_decode_mapping
7925
        if (key == NULL)
7926
            goto onError;
7927
7928
        item = PyObject_GetItem(mapping, key);
inline
               
PyObject_GetItem will not be inlined into charmap_decode_mapping because its definition is unavailable 
charmap_decode_mapping
7929
        Py_DECREF(key);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7930
        if (item == NULL) {
7931
            if (PyErr_ExceptionMatches(PyExc_LookupError)) {
inline
                
PyErr_ExceptionMatches will not be inlined into charmap_decode_mapping because its definition is unavailable 
charmap_decode_mapping
licm
                                       
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_mapping
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
charmap_decode_mapping
licm
                                       
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                       
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7932
                /* No mapping found means: mapping is undefined. */
7933
                PyErr_Clear();
inline
                
PyErr_Clear will not be inlined into charmap_decode_mapping because its definition is unavailable 
charmap_decode_mapping
7934
                goto Undefined;
7935
            } else
7936
                goto onError;
7937
        }
7938
7939
        /* Apply mapping */
7940
        if (item == Py_None)
7941
            goto Undefined;
7942
        if (PyLong_Check(item)) {
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7943
            long value = PyLong_AS_LONG(item);
inline
                         
PyLong_AsLong will not be inlined into charmap_decode_mapping because its definition is unavailable 
charmap_decode_mapping
7944
            if (value == 0xFFFE)
7945
                goto Undefined;
7946
            if (value < 0 || value > MAX_UNICODE) {
7947
                PyErr_Format(PyExc_TypeError,
inline
                
PyErr_Format will not be inlined into charmap_decode_mapping because its definition is unavailable 
charmap_decode_mapping
gvn
                             
load of type %struct._object* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
                             
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7948
                             "character mapping must be in range(0x%lx)",
7949
                             (unsigned long)MAX_UNICODE + 1);
7950
                goto onError;
7951
            }
7952
7953
            if (_PyUnicodeWriter_WriteCharInline(writer, value) < 0)
inline
                
_PyUnicodeWriter_WriteCharInline can be inlined into charmap_decode_mapping with cost=150 (threshold=325) 
charmap_decode_mapping
inline
                
_PyUnicodeWriter_WriteCharInline inlined into charmap_decode_mapping 
charmap_decode_mapping
7954
                goto onError;
7955
        }
7956
        else if (PyUnicode_Check(item)) {
7957
            if (PyUnicode_READY(item) == -1)
inline
                
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
charmap_decode_mapping
inline
                
_PyUnicode_Ready will not be inlined into charmap_decode_mapping 
charmap_decode_mapping
gvn
                
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
                
load of type i32 not eliminated because it is clobbered by store 
charmap_decode_mapping
inline
                
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeCharmap
inline
                
_PyUnicode_Ready will not be inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
gvn
                
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
                
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7958
                goto onError;
7959
            if (PyUnicode_GET_LENGTH(item) == 1) {
gvn
                
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
                
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
                
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7960
                Py_UCS4 value = PyUnicode_READ_CHAR(item, 0);
gvn
                                
load of type i32 not eliminated in favor of load because it is clobbered by call 
charmap_decode_mapping
gvn
                                
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
                                
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
                                
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
                                
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                                
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7961
                if (value == 0xFFFE)
7962
                    goto Undefined;
7963
                if (_PyUnicodeWriter_WriteCharInline(writer, value) < 0)
inline
                    
_PyUnicodeWriter_WriteCharInline can be inlined into charmap_decode_mapping with cost=150 (threshold=325) 
charmap_decode_mapping
inline
                    
_PyUnicodeWriter_WriteCharInline inlined into charmap_decode_mapping 
charmap_decode_mapping
7964
                    goto onError;
7965
            }
7966
            else {
7967
                writer->overallocate = 1;
licm
                        
hosting getelementptr 
charmap_decode_mapping
7968
                if (_PyUnicodeWriter_WriteStr(writer, item) == -1)
inline
                    
_PyUnicodeWriter_WriteStr too costly to inline (cost=445, threshold=250) 
charmap_decode_mapping
inline
                    
_PyUnicodeWriter_WriteStr will not be inlined into charmap_decode_mapping 
charmap_decode_mapping
inline
                    
_PyUnicodeWriter_WriteStr too costly to inline (cost=445, threshold=250) 
PyUnicode_DecodeCharmap
inline
                    
_PyUnicodeWriter_WriteStr will not be inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
7969
                    goto onError;
7970
            }
7971
        }
7972
        else {
7973
            /* wrong return value */
7974
            PyErr_SetString(PyExc_TypeError,
inline
            
PyErr_SetString will not be inlined into charmap_decode_mapping because its definition is unavailable 
charmap_decode_mapping
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7975
                            "character mapping must return integer, None or str");
7976
            goto onError;
7977
        }
7978
        Py_CLEAR(item);
gvn
        
load of type i64 not eliminated because it is clobbered by store 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by store 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by store 
charmap_decode_mapping
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeCharmap
7979
        ++s;
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_mapping
gvn
        
load of type i8* eliminated in favor of phi 
charmap_decode_mapping
7980
        continue;
7981
7982
Undefined:
7983
        /* undefined mapping */
7984
        Py_CLEAR(item);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by store 
charmap_decode_mapping
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
7985
        startinpos = s-starts;
licm
                     
hosting bitcast 
charmap_decode_mapping
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_mapping
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_mapping
gvn
                     
load of type i64 eliminated in favor of phi 
charmap_decode_mapping
gvn
                       
load of type i64 not eliminated in favor of store because it is clobbered by call 
charmap_decode_mapping
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
                       
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
7986
        endinpos = startinpos+1;
7987
        if (unicode_decode_call_errorhandler_writer(
inline
            
unicode_decode_call_errorhandler_writer too costly to inline (cost=630, threshold=625) 
charmap_decode_mapping
inline
            
unicode_decode_call_errorhandler_writer will not be inlined into charmap_decode_mapping 
charmap_decode_mapping
inline
            
unicode_decode_call_errorhandler_writer too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeCharmap
inline
            
unicode_decode_call_errorhandler_writer will not be inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
7988
                errors, &errorHandler,
7989
                "charmap", "character maps to <undefined>",
7990
                &starts, &e, &startinpos, &endinpos, &exc, &s,
7991
                writer)) {
7992
            goto onError;
7993
        }
7994
    }
7995
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
charmap_decode_mapping
gvn
    
load eliminated by PRE 
charmap_decode_mapping
7996
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
7997
    return 0;
7998
7999
onError:
8000
    Py_XDECREF(item);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeCharmap
8001
    Py_XDECREF(errorHandler);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
8002
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
8003
    return -1;
8004
}
8005
8006
PyObject *
8007
PyUnicode_DecodeCharmap(const char *s,
8008
                        Py_ssize_t size,
8009
                        PyObject *mapping,
8010
                        const char *errors)
8011
{
8012
    _PyUnicodeWriter writer;
8013
8014
    /* Default to Latin-1 */
8015
    if (mapping == NULL)
8016
        return PyUnicode_DecodeLatin1(s, size, errors);
inline
               
PyUnicode_DecodeLatin1 can be inlined into PyUnicode_DecodeCharmap with cost=-5 (threshold=375) 
PyUnicode_DecodeCharmap
inline
               
PyUnicode_DecodeLatin1 inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
8017
8018
    if (size == 0)
8019
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_DecodeCharmap
inline
        
PyUnicode_New will not be inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
gvn
        
load of type %struct._object* eliminated in favor of phi 
PyUnicode_DecodeCharmap
8020
    _PyUnicodeWriter_Init(&writer);
inline
    
_PyUnicodeWriter_Init can be inlined into PyUnicode_DecodeCharmap with cost=-30 (threshold=375) 
PyUnicode_DecodeCharmap
inline
    
_PyUnicodeWriter_Init inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
8021
    writer.min_length = size;
8022
    if (_PyUnicodeWriter_Prepare(&writer, writer.min_length, 127) == -1)
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeCharmap
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
gvn
        
load of type i32 eliminated in favor of 0 
PyUnicode_DecodeCharmap
8023
        goto onError;
8024
8025
    if (PyUnicode_CheckExact(mapping)) {
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
8026
        if (charmap_decode_string(s, size, mapping, errors, &writer) < 0)
inline
            
charmap_decode_string can be inlined into PyUnicode_DecodeCharmap with cost=-13745 (threshold=250) 
PyUnicode_DecodeCharmap
inline
            
charmap_decode_string inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
8027
            goto onError;
8028
    }
8029
    else {
8030
        if (charmap_decode_mapping(s, size, mapping, errors, &writer) < 0)
inline
            
charmap_decode_mapping can be inlined into PyUnicode_DecodeCharmap with cost=-13385 (threshold=250) 
PyUnicode_DecodeCharmap
inline
            
charmap_decode_mapping inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
8031
            goto onError;
8032
    }
8033
    return _PyUnicodeWriter_Finish(&writer);
inline
           
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
PyUnicode_DecodeCharmap
inline
           
_PyUnicodeWriter_Finish will not be inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
8034
8035
  onError:
8036
    _PyUnicodeWriter_Dealloc(&writer);
inline
    
_PyUnicodeWriter_Dealloc can be inlined into PyUnicode_DecodeCharmap with cost=20 (threshold=250) 
PyUnicode_DecodeCharmap
inline
    
_PyUnicodeWriter_Dealloc inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
8037
    return NULL;
8038
}
8039
8040
/* Charmap encoding: the lookup table */
8041
8042
struct encoding_map {
8043
    PyObject_HEAD
8044
    unsigned char level1[32];
8045
    int count2, count3;
8046
    unsigned char level23[1];
8047
};
8048
8049
static PyObject*
8050
encoding_map_size(PyObject *obj, PyObject* args)
8051
{
8052
    struct encoding_map *map = (struct encoding_map*)obj;
8053
    return PyLong_FromLong(sizeof(*map) - 1 + 16*map->count2 +
inline
           
PyLong_FromLong will not be inlined into encoding_map_size because its definition is unavailable 
encoding_map_size
8054
                           128*map->count3);
8055
}
8056
8057
static PyMethodDef encoding_map_methods[] = {
8058
    {"size", encoding_map_size, METH_NOARGS,
8059
     PyDoc_STR("Return the size (in bytes) of this object") },
8060
    { 0 }
8061
};
8062
8063
static void
8064
encoding_map_dealloc(PyObject* o)
8065
{
8066
    PyObject_FREE(o);
inline
    
PyObject_Free will not be inlined into encoding_map_dealloc because its definition is unavailable 
encoding_map_dealloc
8067
}
8068
8069
static PyTypeObject EncodingMapType = {
8070
    PyVarObject_HEAD_INIT(NULL, 0)
8071
    "EncodingMap",          /*tp_name*/
8072
    sizeof(struct encoding_map),   /*tp_basicsize*/
8073
    0,                      /*tp_itemsize*/
8074
    /* methods */
8075
    encoding_map_dealloc,   /*tp_dealloc*/
8076
    0,                      /*tp_print*/
8077
    0,                      /*tp_getattr*/
8078
    0,                      /*tp_setattr*/
8079
    0,                      /*tp_reserved*/
8080
    0,                      /*tp_repr*/
8081
    0,                      /*tp_as_number*/
8082
    0,                      /*tp_as_sequence*/
8083
    0,                      /*tp_as_mapping*/
8084
    0,                      /*tp_hash*/
8085
    0,                      /*tp_call*/
8086
    0,                      /*tp_str*/
8087
    0,                      /*tp_getattro*/
8088
    0,                      /*tp_setattro*/
8089
    0,                      /*tp_as_buffer*/
8090
    Py_TPFLAGS_DEFAULT,     /*tp_flags*/
8091
    0,                      /*tp_doc*/
8092
    0,                      /*tp_traverse*/
8093
    0,                      /*tp_clear*/
8094
    0,                      /*tp_richcompare*/
8095
    0,                      /*tp_weaklistoffset*/
8096
    0,                      /*tp_iter*/
8097
    0,                      /*tp_iternext*/
8098
    encoding_map_methods,   /*tp_methods*/
8099
    0,                      /*tp_members*/
8100
    0,                      /*tp_getset*/
8101
    0,                      /*tp_base*/
8102
    0,                      /*tp_dict*/
8103
    0,                      /*tp_descr_get*/
8104
    0,                      /*tp_descr_set*/
8105
    0,                      /*tp_dictoffset*/
8106
    0,                      /*tp_init*/
8107
    0,                      /*tp_alloc*/
8108
    0,                      /*tp_new*/
8109
    0,                      /*tp_free*/
8110
    0,                      /*tp_is_gc*/
8111
};
8112
8113
PyObject*
8114
PyUnicode_BuildEncodingMap(PyObject* string)
8115
{
8116
    PyObject *result;
8117
    struct encoding_map *mresult;
8118
    int i;
8119
    int need_dict = 0;
8120
    unsigned char level1[32];
8121
    unsigned char level2[512];
8122
    unsigned char *mlevel1, *mlevel2, *mlevel3;
8123
    int count2 = 0, count3 = 0;
8124
    int kind;
8125
    void *data;
8126
    Py_ssize_t length;
8127
    Py_UCS4 ch;
8128
8129
    if (!PyUnicode_Check(string) || !PyUnicode_GET_LENGTH(string)) {
8130
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_BuildEncodingMap because its definition is unavailable 
PyUnicode_BuildEncodingMap
8131
        return NULL;
8132
    }
8133
    kind = PyUnicode_KIND(string);
8134
    data = PyUnicode_DATA(string);
8135
    length = PyUnicode_GET_LENGTH(string);
8136
    length = Py_MIN(length, 256);
8137
    memset(level1, 0xFF, sizeof level1);
8138
    memset(level2, 0xFF, sizeof level2);
8139
8140
    /* If there isn't a one-to-one mapping of NULL to \0,
8141
       or if there are non-BMP characters, we need to use
8142
       a mapping dictionary. */
8143
    if (PyUnicode_READ(kind, data, 0) != 0)
8144
        need_dict = 1;
8145
    for (i = 1; i < length; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_BuildEncodingMap
loop-vectorize
    
loop not vectorized 
PyUnicode_BuildEncodingMap
8146
        int l1, l2;
8147
        ch = PyUnicode_READ(kind, data, i);
licm
             
hosting icmp 
PyUnicode_BuildEncodingMap
licm
             
hosting bitcast 
PyUnicode_BuildEncodingMap
8148
        if (ch == 0 || ch > 0xFFFF) {
8149
            need_dict = 1;
8150
            break;
8151
        }
8152
        if (ch == 0xFFFE)
8153
            /* unmapped character */
8154
            continue;
8155
        l1 = ch >> 11;
8156
        l2 = ch >> 7;
8157
        if (level1[l1] == 0xFF)
gvn
            
load of type i8 eliminated in favor of phi 
PyUnicode_BuildEncodingMap
8158
            level1[l1] = count2++;
licm
                       
Moving accesses to memory location out of the loop 
PyUnicode_BuildEncodingMap
8159
        if (level2[l2] == 0xFF)
8160
            level2[l2] = count3++;
8161
    }
8162
8163
    if (count2 >= 0xFF || count3 >= 0xFF)
8164
        need_dict = 1;
8165
8166
    if (need_dict) {
8167
        PyObject *result = PyDict_New();
inline
                           
PyDict_New will not be inlined into PyUnicode_BuildEncodingMap because its definition is unavailable 
PyUnicode_BuildEncodingMap
8168
        PyObject *key, *value;
8169
        if (!result)
8170
            return NULL;
8171
        for (i = 0; i < length; i++) {
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_BuildEncodingMap
loop-vectorize
        
loop not vectorized 
PyUnicode_BuildEncodingMap
8172
            key = PyLong_FromLong(PyUnicode_READ(kind, data, i));
inline
                  
PyLong_FromLong will not be inlined into PyUnicode_BuildEncodingMap because its definition is unavailable 
PyUnicode_BuildEncodingMap
licm
                                  
hosting icmp 
PyUnicode_BuildEncodingMap
licm
                                  
hosting bitcast 
PyUnicode_BuildEncodingMap
gvn
                                  
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
                                  
load of type i16 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
                                  
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
8173
            value = PyLong_FromLong(i);
inline
                    
PyLong_FromLong will not be inlined into PyUnicode_BuildEncodingMap because its definition is unavailable 
PyUnicode_BuildEncodingMap
8174
            if (!key || !value)
8175
                goto failed1;
8176
            if (PyDict_SetItem(result, key, value) == -1)
inline
                
PyDict_SetItem will not be inlined into PyUnicode_BuildEncodingMap because its definition is unavailable 
PyUnicode_BuildEncodingMap
8177
                goto failed1;
8178
            Py_DECREF(key);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
8179
            Py_DECREF(value);
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_BuildEncodingMap
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
8180
        }
8181
        return result;
8182
      failed1:
8183
        Py_XDECREF(key);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
8184
        Py_XDECREF(value);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_BuildEncodingMap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
8185
        Py_DECREF(result);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_BuildEncodingMap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_BuildEncodingMap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
8186
        return NULL;
8187
    }
8188
8189
    /* Create a three-level trie */
8190
    result = PyObject_MALLOC(sizeof(struct encoding_map) +
inline
             
PyObject_Malloc will not be inlined into PyUnicode_BuildEncodingMap because its definition is unavailable 
PyUnicode_BuildEncodingMap
8191
                             16*count2 + 128*count3 - 1);
8192
    if (!result)
8193
        return PyErr_NoMemory();
inline
               
PyErr_NoMemory will not be inlined into PyUnicode_BuildEncodingMap because its definition is unavailable 
PyUnicode_BuildEncodingMap
8194
    PyObject_Init(result, &EncodingMapType);
inline
    
PyObject_Init will not be inlined into PyUnicode_BuildEncodingMap because its definition is unavailable 
PyUnicode_BuildEncodingMap
8195
    mresult = (struct encoding_map*)result;
8196
    mresult->count2 = count2;
8197
    mresult->count3 = count3;
8198
    mlevel1 = mresult->level1;
8199
    mlevel2 = mresult->level23;
8200
    mlevel3 = mresult->level23 + 16*count2;
8201
    memcpy(mlevel1, level1, 32);
8202
    memset(mlevel2, 0xFF, 16*count2);
8203
    memset(mlevel3, 0, 128*count3);
8204
    count3 = 0;
8205
    for (i = 1; i < length; i++) {
loop-vectorize
    
loop not vectorized 
PyUnicode_BuildEncodingMap
loop-vectorize
    
loop not vectorized: value that could not be identified as reduction is used outside the loop 
PyUnicode_BuildEncodingMap
8206
        int o1, o2, o3, i2, i3;
8207
        Py_UCS4 ch = PyUnicode_READ(kind, data, i);
licm
                     
hosting icmp 
PyUnicode_BuildEncodingMap
licm
                     
hosting bitcast 
PyUnicode_BuildEncodingMap
8208
        if (ch == 0xFFFE)
8209
            /* unmapped character */
8210
            continue;
8211
        o1 = ch>>11;
8212
        o2 = (ch>>7) & 0xF;
8213
        i2 = 16*mlevel1[o1] + o2;
gvn
                
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_BuildEncodingMap
gvn
                
load of type i8 not eliminated because it is clobbered by call 
PyUnicode_BuildEncodingMap
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_BuildEncodingMap
8214
        if (mlevel2[i2] == 0xFF)
loop-vectorize
            
loop not vectorized: control flow cannot be substituted for a select 
PyUnicode_BuildEncodingMap
8215
            mlevel2[i2] = count3++;
8216
        o3 = ch & 0x7F;
8217
        i3 = 128*mlevel2[i2] + o3;
gvn
                 
load of type i8 eliminated in favor of phi 
PyUnicode_BuildEncodingMap
8218
        mlevel3[i3] = i;
8219
    }
8220
    return result;
8221
}
8222
8223
static int
8224
encoding_map_lookup(Py_UCS4 c, PyObject *mapping)
8225
{
8226
    struct encoding_map *map = (struct encoding_map*)mapping;
8227
    int l1 = c>>11;
8228
    int l2 = (c>>7) & 0xF;
8229
    int l3 = c & 0x7F;
8230
    int i;
8231
8232
    if (c > 0xFFFF)
8233
        return -1;
8234
    if (c == 0)
8235
        return 0;
8236
    /* level 1*/
8237
    i = map->level1[l1];
licm
             
hosting getelementptr 
charmap_encoding_error
licm
             
hosting bitcast 
charmap_encoding_error
8238
    if (i == 0xFF) {
8239
        return -1;
8240
    }
8241
    /* level 2*/
8242
    i = map->level23[16*i+l2];
licm
             
hosting getelementptr 
charmap_encoding_error
licm
             
hosting bitcast 
charmap_encoding_error
8243
    if (i == 0xFF) {
8244
        return -1;
8245
    }
8246
    /* level 3 */
8247
    i = map->level23[16*map->count2 + 128*i + l3];
licm
                             
hosting getelementptr 
charmap_encoding_error
licm
                             
hosting bitcast 
charmap_encoding_error
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_encoding_error
gvn
                             
load of type i32 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                             
load of type i32 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                             
load of type i32 not eliminated because it is clobbered by call 
charmap_encoding_error
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
                             
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                             
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                             
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                             
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8248
    if (i == 0) {
8249
        return -1;
8250
    }
8251
    return i;
8252
}
8253
8254
/* Lookup the character ch in the mapping. If the character
8255
   can't be found, Py_None is returned (or NULL, if another
8256
   error occurred). */
8257
static PyObject *
8258
charmapencode_lookup(Py_UCS4 c, PyObject *mapping)
8259
{
8260
    PyObject *w = PyLong_FromLong((long)c);
inline
                  
PyLong_FromLong will not be inlined into charmapencode_lookup because its definition is unavailable 
charmapencode_lookup
8261
    PyObject *x;
8262
8263
    if (w == NULL)
8264
        return NULL;
8265
    x = PyObject_GetItem(mapping, w);
inline
        
PyObject_GetItem will not be inlined into charmapencode_lookup because its definition is unavailable 
charmapencode_lookup
8266
    Py_DECREF(w);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
charmapencode_lookup
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmapencode_lookup
8267
    if (x == NULL) {
8268
        if (PyErr_ExceptionMatches(PyExc_LookupError)) {
inline
            
PyErr_ExceptionMatches will not be inlined into charmapencode_lookup because its definition is unavailable 
charmapencode_lookup
gvn
                                   
load of type %struct._object* not eliminated because it is clobbered by call 
charmapencode_lookup
gvn
                                   
load of type %struct._object* not eliminated because it is clobbered by call 
charmapencode_lookup
8269
            /* No mapping found means: mapping is undefined. */
8270
            PyErr_Clear();
inline
            
PyErr_Clear will not be inlined into charmapencode_lookup because its definition is unavailable 
charmapencode_lookup
8271
            x = Py_None;
8272
            Py_INCREF(x);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
charmapencode_lookup
8273
            return x;
8274
        } else
8275
            return NULL;
8276
    }
8277
    else if (x == Py_None)
8278
        return x;
8279
    else if (PyLong_Check(x)) {
gvn
             
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmapencode_lookup
gvn
             
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmapencode_lookup
8280
        long value = PyLong_AS_LONG(x);
inline
                     
PyLong_AsLong will not be inlined into charmapencode_lookup because its definition is unavailable 
charmapencode_lookup
8281
        if (value < 0 || value > 255) {
8282
            PyErr_SetString(PyExc_TypeError,
inline
            
PyErr_SetString will not be inlined into charmapencode_lookup because its definition is unavailable 
charmapencode_lookup
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
charmapencode_lookup
8283
                            "character mapping must be in range(256)");
8284
            Py_DECREF(x);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
charmapencode_lookup
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmapencode_lookup
8285
            return NULL;
8286
        }
8287
        return x;
8288
    }
8289
    else if (PyBytes_Check(x))
8290
        return x;
8291
    else {
8292
        /* wrong return value */
8293
        PyErr_Format(PyExc_TypeError,
inline
        
PyErr_Format will not be inlined into charmapencode_lookup because its definition is unavailable 
charmapencode_lookup
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
charmapencode_lookup
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
charmapencode_lookup
8294
                     "character mapping must return integer, bytes or None, not %.400s",
8295
                     x->ob_type->tp_name);
8296
        Py_DECREF(x);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmapencode_lookup
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmapencode_lookup
8297
        return NULL;
8298
    }
8299
}
8300
8301
static int
8302
charmapencode_resize(PyObject **outobj, Py_ssize_t *outpos, Py_ssize_t requiredsize)
8303
{
8304
    Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
gvn
                         
load of type %struct.PyVarObject* not eliminated in favor of load because it is clobbered by call 
charmapencode_output
gvn
                         
load of type %struct.PyVarObject* eliminated in favor of load 
charmapencode_output
gvn
                         
load of type i64 eliminated in favor of load 
charmapencode_output
gvn
                         
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
charmap_encoding_error
licm
                         
hosting bitcast 
_PyUnicode_EncodeCharmap
licm
                         
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
                         
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8305
    /* exponentially overallocate to minimize reallocations */
8306
    if (requiredsize < 2*outsize)
8307
        requiredsize = 2*outsize;
8308
    if (_PyBytes_Resize(outobj, requiredsize))
inline
        
_PyBytes_Resize will not be inlined into charmapencode_resize because its definition is unavailable 
charmapencode_resize
8309
        return -1;
8310
    return 0;
8311
}
8312
8313
typedef enum charmapencode_result {
8314
    enc_SUCCESS, enc_FAILED, enc_EXCEPTION
8315
} charmapencode_result;
8316
/* lookup the character, put the result in the output string and adjust
8317
   various state variables. Resize the output bytes object if not enough
8318
   space is available. Return a new reference to the object that
8319
   was put in the output buffer, or Py_None, if the mapping was undefined
8320
   (in which case no character was written) or NULL, if a
8321
   reallocation error occurred. The caller must decref the result */
8322
static charmapencode_result
8323
charmapencode_output(Py_UCS4 c, PyObject *mapping,
8324
                     PyObject **outobj, Py_ssize_t *outpos)
8325
{
8326
    PyObject *rep;
8327
    char *outstart;
8328
    Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
8329
8330
    if (Py_TYPE(mapping) == &EncodingMapType) {
8331
        int res = encoding_map_lookup(c, mapping);
inline
                  
encoding_map_lookup can be inlined into charmapencode_output with cost=120 (threshold=250) 
charmapencode_output
inline
                  
encoding_map_lookup inlined into charmapencode_output 
charmapencode_output
8332
        Py_ssize_t requiredsize = *outpos+1;
8333
        if (res == -1)
8334
            return enc_FAILED;
8335
        if (outsize<requiredsize)
8336
            if (charmapencode_resize(outobj, outpos, requiredsize))
inline
                
charmapencode_resize can be inlined into charmapencode_output with cost=30 (threshold=375) 
charmapencode_output
inline
                
charmapencode_resize inlined into charmapencode_output 
charmapencode_output
8337
                return enc_EXCEPTION;
8338
        outstart = PyBytes_AS_STRING(*outobj);
gvn
                   
load of type %struct.PyBytesObject* not eliminated because it is clobbered by call 
charmapencode_output
gvn
                   
load eliminated by PRE 
charmapencode_output
8339
        outstart[(*outpos)++] = (char)res;
gvn
                          
load of type i64 not eliminated in favor of load because it is clobbered by call 
charmapencode_output
gvn
                          
load eliminated by PRE 
charmapencode_output
8340
        return enc_SUCCESS;
8341
    }
8342
8343
    rep = charmapencode_lookup(c, mapping);
inline
          
charmapencode_lookup too costly to inline (cost=480, threshold=250) 
charmapencode_output
inline
          
charmapencode_lookup will not be inlined into charmapencode_output 
charmapencode_output
8344
    if (rep==NULL)
8345
        return enc_EXCEPTION;
8346
    else if (rep==Py_None) {
8347
        Py_DECREF(rep);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmapencode_output
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmapencode_output
8348
        return enc_FAILED;
8349
    } else {
8350
        if (PyLong_Check(rep)) {
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmapencode_output
8351
            Py_ssize_t requiredsize = *outpos+1;
gvn
                                      
load of type i64 not eliminated because it is clobbered by call 
charmapencode_output
8352
            if (outsize<requiredsize)
8353
                if (charmapencode_resize(outobj, outpos, requiredsize)) {
inline
                    
charmapencode_resize can be inlined into charmapencode_output with cost=30 (threshold=375) 
charmapencode_output
inline
                    
charmapencode_resize inlined into charmapencode_output 
charmapencode_output
8354
                    Py_DECREF(rep);
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
charmapencode_output
gvn
                    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmapencode_output
8355
                    return enc_EXCEPTION;
8356
                }
8357
            outstart = PyBytes_AS_STRING(*outobj);
gvn
                       
load of type %struct.PyBytesObject* not eliminated because it is clobbered by call 
charmapencode_output
gvn
                       
load of type %struct.PyBytesObject* not eliminated because it is clobbered by call 
charmapencode_output
8358
            outstart[(*outpos)++] = (char)PyLong_AS_LONG(rep);
inline
                                          
PyLong_AsLong will not be inlined into charmapencode_output because its definition is unavailable 
charmapencode_output
gvn
                              
load of type i64 not eliminated in favor of load because it is clobbered by call 
charmapencode_output
8359
        }
8360
        else {
8361
            const char *repchars = PyBytes_AS_STRING(rep);
8362
            Py_ssize_t repsize = PyBytes_GET_SIZE(rep);
gvn
                                 
load of type i64 not eliminated because it is clobbered by call 
charmapencode_output
8363
            Py_ssize_t requiredsize = *outpos+repsize;
8364
            if (outsize<requiredsize)
8365
                if (charmapencode_resize(outobj, outpos, requiredsize)) {
inline
                    
charmapencode_resize can be inlined into charmapencode_output with cost=30 (threshold=375) 
charmapencode_output
inline
                    
charmapencode_resize inlined into charmapencode_output 
charmapencode_output
8366
                    Py_DECREF(rep);
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
charmapencode_output
gvn
                    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmapencode_output
8367
                    return enc_EXCEPTION;
8368
                }
8369
            outstart = PyBytes_AS_STRING(*outobj);
gvn
                       
load of type %struct.PyBytesObject* not eliminated because it is clobbered by call 
charmapencode_output
gvn
                       
load of type %struct.PyBytesObject* not eliminated because it is clobbered by call 
charmapencode_output
8370
            memcpy(outstart + *outpos, repchars, repsize);
gvn
                              
load of type i64 not eliminated in favor of load because it is clobbered by call 
charmapencode_output
gvn
                              
load eliminated by PRE 
charmapencode_output
8371
            *outpos += repsize;
gvn
                    
load of type i64 not eliminated in favor of load because it is clobbered by call 
charmapencode_output
8372
        }
8373
    }
8374
    Py_DECREF(rep);
gvn
    
load of type i64 not eliminated because it is clobbered by store 
charmapencode_output
gvn
    
load of type i64 not eliminated because it is clobbered by store 
charmapencode_output
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by store 
charmapencode_output
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmapencode_output
8375
    return enc_SUCCESS;
8376
}
8377
8378
/* handle an error in PyUnicode_EncodeCharmap
8379
   Return 0 on success, -1 on error */
8380
static int
8381
charmap_encoding_error(
8382
    PyObject *unicode, Py_ssize_t *inpos, PyObject *mapping,
8383
    PyObject **exceptionObject,
8384
    _Py_error_handler *error_handler, PyObject **error_handler_obj, const char *errors,
8385
    PyObject **res, Py_ssize_t *respos)
8386
{
8387
    PyObject *repunicode = NULL; /* initialize to prevent gcc warning */
8388
    Py_ssize_t size, repsize;
8389
    Py_ssize_t newpos;
licm
    
hosting bitcast 
_PyUnicode_EncodeCharmap
8390
    enum PyUnicode_Kind kind;
8391
    void *data;
8392
    Py_ssize_t index;
8393
    /* startpos for collecting unencodable chars */
8394
    Py_ssize_t collstartpos = *inpos;
8395
    Py_ssize_t collendpos = *inpos+1;
8396
    Py_ssize_t collpos;
8397
    char *encoding = "charmap";
8398
    char *reason = "character maps to <undefined>";
8399
    charmapencode_result x;
8400
    Py_UCS4 ch;
8401
    int val;
8402
8403
    if (PyUnicode_READY(unicode) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
charmap_encoding_error
inline
        
_PyUnicode_Ready will not be inlined into charmap_encoding_error 
charmap_encoding_error
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeCharmap
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_EncodeCharmap 
_PyUnicode_EncodeCharmap
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeCharmap
8404
        return -1;
8405
    size = PyUnicode_GET_LENGTH(unicode);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
           
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
           
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeCharmap
8406
    /* find all unencodable characters */
8407
    while (collendpos < size) {
8408
        PyObject *rep;
8409
        if (Py_TYPE(mapping) == &EncodingMapType) {
licm
            
hosting getelementptr 
charmap_encoding_error
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_encoding_error
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmap_encoding_error
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_EncodeCharmap
loop-vectorize
            
loop not vectorized 
_PyUnicode_EncodeCharmap
8410
            ch = PyUnicode_READ_CHAR(unicode, collendpos);
licm
                 
hosting getelementptr 
charmap_encoding_error
licm
                 
hosting bitcast 
charmap_encoding_error
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_encoding_error
gvn
                 
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                 
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                 
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
                 
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                 
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                 
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                 
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8411
            val = encoding_map_lookup(ch, mapping);
inline
                  
encoding_map_lookup can be inlined into charmap_encoding_error with cost=-14880 (threshold=250) 
charmap_encoding_error
inline
                  
encoding_map_lookup inlined into charmap_encoding_error 
charmap_encoding_error
8412
            if (val != -1)
8413
                break;
8414
            ++collendpos;
8415
            continue;
8416
        }
8417
8418
        ch = PyUnicode_READ_CHAR(unicode, collendpos);
licm
             
hosting getelementptr 
charmap_encoding_error
licm
             
hosting bitcast 
charmap_encoding_error
licm
             
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_encoding_error
gvn
             
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
             
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
             
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
licm
             
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
             
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
             
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
             
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
             
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8419
        rep = charmapencode_lookup(ch, mapping);
inline
              
charmapencode_lookup too costly to inline (cost=480, threshold=250) 
charmap_encoding_error
inline
              
charmapencode_lookup will not be inlined into charmap_encoding_error 
charmap_encoding_error
inline
              
charmapencode_lookup too costly to inline (cost=480, threshold=250) 
_PyUnicode_EncodeCharmap
inline
              
charmapencode_lookup will not be inlined into _PyUnicode_EncodeCharmap 
_PyUnicode_EncodeCharmap
8420
        if (rep==NULL)
8421
            return -1;
8422
        else if (rep!=Py_None) {
8423
            Py_DECREF(rep);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8424
            break;
8425
        }
8426
        Py_DECREF(rep);
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmap_encoding_error
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_encoding_error
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8427
        ++collendpos;
8428
    }
8429
    /* cache callback name lookup
8430
     * (if not done yet, i.e. it's the first error) */
8431
    if (*error_handler == _Py_ERROR_UNKNOWN)
gvn
        
load of type i32 not eliminated because it is clobbered by store 
charmap_encoding_error
gvn
        
load of type i32 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
        
load of type i32 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
        
load of type i32 not eliminated because it is clobbered by call 
charmap_encoding_error
8432
        *error_handler = get_error_handler(errors);
inline
                         
get_error_handler too costly to inline (cost=325, threshold=250) 
charmap_encoding_error
inline
                         
get_error_handler will not be inlined into charmap_encoding_error 
charmap_encoding_error
inline
                         
get_error_handler too costly to inline (cost=325, threshold=250) 
_PyUnicode_EncodeCharmap
inline
                         
get_error_handler will not be inlined into _PyUnicode_EncodeCharmap 
_PyUnicode_EncodeCharmap
8433
8434
    switch (*error_handler) {
8435
    case _Py_ERROR_STRICT:
8436
        raise_encode_exception(exceptionObject, encoding, unicode, collstartpos, collendpos, reason);
inline
        
raise_encode_exception can be inlined into charmap_encoding_error with cost=50 (threshold=250) 
charmap_encoding_error
inline
        
raise_encode_exception inlined into charmap_encoding_error 
charmap_encoding_error
8437
        return -1;
8438
8439
    case _Py_ERROR_REPLACE:
8440
        for (collpos = collstartpos; collpos<collendpos; ++collpos) {
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_EncodeCharmap
loop-vectorize
        
loop not vectorized 
_PyUnicode_EncodeCharmap
8441
            x = charmapencode_output('?', mapping, res, respos);
inline
                
charmapencode_output too costly to inline (cost=650, threshold=625) 
charmap_encoding_error
inline
                
charmapencode_output will not be inlined into charmap_encoding_error 
charmap_encoding_error
inline
                
charmapencode_output too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeCharmap
inline
                
charmapencode_output will not be inlined into _PyUnicode_EncodeCharmap 
_PyUnicode_EncodeCharmap
8442
            if (x==enc_EXCEPTION) {
8443
                return -1;
8444
            }
8445
            else if (x==enc_FAILED) {
8446
                raise_encode_exception(exceptionObject, encoding, unicode, collstartpos, collendpos, reason);
inline
                
raise_encode_exception can be inlined into charmap_encoding_error with cost=50 (threshold=250) 
charmap_encoding_error
inline
                
raise_encode_exception inlined into charmap_encoding_error 
charmap_encoding_error
8447
                return -1;
8448
            }
8449
        }
8450
        /* fall through */
8451
    case _Py_ERROR_IGNORE:
8452
        *inpos = collendpos;
8453
        break;
8454
8455
    case _Py_ERROR_XMLCHARREFREPLACE:
8456
        /* generate replacement (temporarily (mis)uses p) */
8457
        for (collpos = collstartpos; collpos < collendpos; ++collpos) {
8458
            char buffer[2+29+1+1];
licm
            
hosting getelementptr 
charmap_encoding_error
8459
            char *cp;
8460
            sprintf(buffer, "&#%d;", (int)PyUnicode_READ_CHAR(unicode, collpos));
inline
            
sprintf will not be inlined into charmap_encoding_error because its definition is unavailable 
charmap_encoding_error
licm
                                          
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_encoding_error
licm
                                          
hosting getelementptr 
charmap_encoding_error
licm
                                          
hosting bitcast 
charmap_encoding_error
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by store 
charmap_encoding_error
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by store 
charmap_encoding_error
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                                          
load of type i8* not eliminated because it is clobbered by store 
charmap_encoding_error
licm
                                          
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
                                          
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                                          
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                                          
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                                          
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_EncodeCharmap
gvn
                                          
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                                          
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                                          
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8461
            for (cp = buffer; *cp; ++cp) {
licm
                              
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_encoding_error
gvn
                              
load of type i8 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                              
load of type i8 not eliminated because it is clobbered by call 
charmap_encoding_error
licm
                              
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
                              
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                              
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_EncodeCharmap
loop-vectorize
            
loop not vectorized 
_PyUnicode_EncodeCharmap
8462
                x = charmapencode_output(*cp, mapping, res, respos);
inline
                    
charmapencode_output too costly to inline (cost=630, threshold=625) 
charmap_encoding_error
inline
                    
charmapencode_output will not be inlined into charmap_encoding_error 
charmap_encoding_error
inline
                    
charmapencode_output too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeCharmap
inline
                    
charmapencode_output will not be inlined into _PyUnicode_EncodeCharmap 
_PyUnicode_EncodeCharmap
8463
                if (x==enc_EXCEPTION)
8464
                    return -1;
8465
                else if (x==enc_FAILED) {
8466
                    raise_encode_exception(exceptionObject, encoding, unicode, collstartpos, collendpos, reason);
inline
                    
raise_encode_exception can be inlined into charmap_encoding_error with cost=50 (threshold=250) 
charmap_encoding_error
inline
                    
raise_encode_exception inlined into charmap_encoding_error 
charmap_encoding_error
8467
                    return -1;
8468
                }
8469
            }
8470
        }
8471
        *inpos = collendpos;
8472
        break;
8473
8474
    default:
8475
        repunicode = unicode_encode_call_errorhandler(errors, error_handler_obj,
inline
                     
unicode_encode_call_errorhandler too costly to inline (cost=630, threshold=625) 
charmap_encoding_error
inline
                     
unicode_encode_call_errorhandler will not be inlined into charmap_encoding_error 
charmap_encoding_error
inline
                     
unicode_encode_call_errorhandler too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeCharmap
inline
                     
unicode_encode_call_errorhandler will not be inlined into _PyUnicode_EncodeCharmap 
_PyUnicode_EncodeCharmap
8476
                                                      encoding, reason, unicode, exceptionObject,
8477
                                                      collstartpos, collendpos, &newpos);
8478
        if (repunicode == NULL)
8479
            return -1;
8480
        if (PyBytes_Check(repunicode)) {
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8481
            /* Directly copy bytes result to output. */
8482
            Py_ssize_t outsize = PyBytes_Size(*res);
inline
                                 
PyBytes_Size will not be inlined into charmap_encoding_error because its definition is unavailable 
charmap_encoding_error
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
charmap_encoding_error
licm
                                              
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8483
            Py_ssize_t requiredsize;
8484
            repsize = PyBytes_Size(repunicode);
inline
                      
PyBytes_Size will not be inlined into charmap_encoding_error because its definition is unavailable 
charmap_encoding_error
8485
            requiredsize = *respos + repsize;
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
licm
                           
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
8486
            if (requiredsize > outsize)
8487
                /* Make room for all additional bytes. */
8488
                if (charmapencode_resize(res, respos, requiredsize)) {
inline
                    
charmapencode_resize can be inlined into charmap_encoding_error with cost=-14970 (threshold=375) 
charmap_encoding_error
inline
                    
charmapencode_resize inlined into charmap_encoding_error 
charmap_encoding_error
8489
                    Py_DECREF(repunicode);
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeCharmap
8490
                    return -1;
8491
                }
8492
            memcpy(PyBytes_AsString(*res) + *respos,
inline
                   
PyBytes_AsString will not be inlined into charmap_encoding_error because its definition is unavailable 
charmap_encoding_error
gvn
                                    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
                                    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
                                            
load of type i64 not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
licm
                                    
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
licm
                                            
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
                                    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                                    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                                            
load of type i64 eliminated in favor of load 
_PyUnicode_EncodeCharmap
8493
                   PyBytes_AsString(repunicode),  repsize);
inline
                   
PyBytes_AsString will not be inlined into charmap_encoding_error because its definition is unavailable 
charmap_encoding_error
8494
            *respos += repsize;
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
8495
            *inpos = newpos;
gvn
                     
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
                     
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8496
            Py_DECREF(repunicode);
gvn
            
load of type i64 not eliminated because it is clobbered by store 
charmap_encoding_error
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeCharmap
8497
            break;
8498
        }
8499
        /* generate replacement  */
8500
        if (PyUnicode_READY(repunicode) == -1) {
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
charmap_encoding_error
inline
            
_PyUnicode_Ready will not be inlined into charmap_encoding_error 
charmap_encoding_error
gvn
            
load of type i32 not eliminated because it is clobbered by call 
charmap_encoding_error
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeCharmap
inline
            
_PyUnicode_Ready will not be inlined into _PyUnicode_EncodeCharmap 
_PyUnicode_EncodeCharmap
gvn
            
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8501
            Py_DECREF(repunicode);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeCharmap
8502
            return -1;
8503
        }
8504
        repsize = PyUnicode_GET_LENGTH(repunicode);
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8505
        data = PyUnicode_DATA(repunicode);
gvn
               
load of type i32 not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
               
load eliminated by PRE 
charmap_encoding_error
gvn
               
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
               
load of type i8* not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
               
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8506
        kind = PyUnicode_KIND(repunicode);
8507
        for (index = 0; index < repsize; index++) {
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_EncodeCharmap
loop-vectorize
        
loop not vectorized 
_PyUnicode_EncodeCharmap
8508
            Py_UCS4 repch = PyUnicode_READ(kind, data, index);
licm
                            
hosting trunc 
charmap_encoding_error
licm
                            
hosting bitcast 
charmap_encoding_error
8509
            x = charmapencode_output(repch, mapping, res, respos);
inline
                
charmapencode_output too costly to inline (cost=630, threshold=625) 
charmap_encoding_error
inline
                
charmapencode_output will not be inlined into charmap_encoding_error 
charmap_encoding_error
inline
                
charmapencode_output too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeCharmap
inline
                
charmapencode_output will not be inlined into _PyUnicode_EncodeCharmap 
_PyUnicode_EncodeCharmap
8510
            if (x==enc_EXCEPTION) {
8511
                Py_DECREF(repunicode);
gvn
                
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
                
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeCharmap
8512
                return -1;
8513
            }
8514
            else if (x==enc_FAILED) {
8515
                Py_DECREF(repunicode);
gvn
                
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
                
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeCharmap
8516
                raise_encode_exception(exceptionObject, encoding, unicode, collstartpos, collendpos, reason);
inline
                
raise_encode_exception can be inlined into charmap_encoding_error with cost=50 (threshold=250) 
charmap_encoding_error
inline
                
raise_encode_exception inlined into charmap_encoding_error 
charmap_encoding_error
8517
                return -1;
8518
            }
8519
        }
8520
        *inpos = newpos;
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
charmap_encoding_error
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_EncodeCharmap
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8521
        Py_DECREF(repunicode);
gvn
        
load of type i64 not eliminated because it is clobbered by store 
charmap_encoding_error
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmap_encoding_error
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeCharmap
8522
    }
8523
    return 0;
8524
}
8525
8526
PyObject *
8527
_PyUnicode_EncodeCharmap(PyObject *unicode,
8528
                         PyObject *mapping,
8529
                         const char *errors)
8530
{
8531
    /* output object */
8532
    PyObject *res = NULL;
8533
    /* current input position */
8534
    Py_ssize_t inpos = 0;
8535
    Py_ssize_t size;
8536
    /* current output position */
8537
    Py_ssize_t respos = 0;
8538
    PyObject *error_handler_obj = NULL;
8539
    PyObject *exc = NULL;
8540
    _Py_error_handler error_handler = _Py_ERROR_UNKNOWN;
8541
    void *data;
8542
    int kind;
8543
8544
    if (PyUnicode_READY(unicode) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeCharmap
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_EncodeCharmap 
_PyUnicode_EncodeCharmap
8545
        return NULL;
8546
    size = PyUnicode_GET_LENGTH(unicode);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8547
    data = PyUnicode_DATA(unicode);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
           
load eliminated by PRE 
_PyUnicode_EncodeCharmap
gvn
           
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8548
    kind = PyUnicode_KIND(unicode);
8549
8550
    /* Default to Latin-1 */
8551
    if (mapping == NULL)
8552
        return unicode_encode_ucs1(unicode, errors, 256);
inline
               
unicode_encode_ucs1 too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeCharmap
inline
               
unicode_encode_ucs1 will not be inlined into _PyUnicode_EncodeCharmap 
_PyUnicode_EncodeCharmap
8553
8554
    /* allocate enough for a simple encoding without
8555
       replacements, if we need more, we'll resize */
8556
    res = PyBytes_FromStringAndSize(NULL, size);
inline
          
PyBytes_FromStringAndSize will not be inlined into _PyUnicode_EncodeCharmap because its definition is unavailable 
_PyUnicode_EncodeCharmap
8557
    if (res == NULL)
8558
        goto onError;
8559
    if (size == 0)
8560
        return res;
8561
8562
    while (inpos<size) {
8563
        Py_UCS4 ch = PyUnicode_READ(kind, data, inpos);
licm
                     
hosting trunc 
_PyUnicode_EncodeCharmap
licm
                     
hosting bitcast 
_PyUnicode_EncodeCharmap
loop-vectorize
                     
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_EncodeCharmap
loop-vectorize
                     
loop not vectorized 
_PyUnicode_EncodeCharmap
8564
        /* try to encode it */
8565
        charmapencode_result x = charmapencode_output(ch, mapping, &res, &respos);
inline
                                 
charmapencode_output too costly to inline (cost=630, threshold=625) 
_PyUnicode_EncodeCharmap
inline
                                 
charmapencode_output will not be inlined into _PyUnicode_EncodeCharmap 
_PyUnicode_EncodeCharmap
8566
        if (x==enc_EXCEPTION) /* error */
8567
            goto onError;
8568
        if (x==enc_FAILED) { /* unencodable character */
8569
            if (charmap_encoding_error(unicode, &inpos, mapping,
inline
                
charmap_encoding_error can be inlined into _PyUnicode_EncodeCharmap with cost=-12375 (threshold=250) 
_PyUnicode_EncodeCharmap
inline
                
charmap_encoding_error inlined into _PyUnicode_EncodeCharmap 
_PyUnicode_EncodeCharmap
8570
                                       &exc,
8571
                                       &error_handler, &error_handler_obj, errors,
8572
                                       &res, &respos)) {
8573
                goto onError;
8574
            }
8575
        }
8576
        else
8577
            /* done with this character => adjust input position */
8578
            ++inpos;
8579
    }
8580
8581
    /* Resize if we allocated to much */
8582
    if (respos<PyBytes_GET_SIZE(res))
gvn
        
load of type i64 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type i64 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type i64 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
        
load of type i64 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
               
load of type %struct.PyVarObject* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8583
        if (_PyBytes_Resize(&res, respos) < 0)
inline
            
_PyBytes_Resize will not be inlined into _PyUnicode_EncodeCharmap because its definition is unavailable 
_PyUnicode_EncodeCharmap
8584
            goto onError;
8585
8586
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
8587
    Py_XDECREF(error_handler_obj);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
8588
    return res;
gvn
           
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
           
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
           
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8589
8590
  onError:
8591
    Py_XDECREF(res);
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_EncodeCharmap
8592
    Py_XDECREF(exc);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
8593
    Py_XDECREF(error_handler_obj);
gvn
    
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_EncodeCharmap
8594
    return NULL;
8595
}
8596
8597
/* Deprecated */
8598
PyObject *
8599
PyUnicode_EncodeCharmap(const Py_UNICODE *p,
8600
                        Py_ssize_t size,
8601
                        PyObject *mapping,
8602
                        const char *errors)
8603
{
8604
    PyObject *result;
8605
    PyObject *unicode = PyUnicode_FromUnicode(p, size);
inline
                        
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeCharmap
inline
                        
PyUnicode_FromUnicode will not be inlined into PyUnicode_EncodeCharmap 
PyUnicode_EncodeCharmap
8606
    if (unicode == NULL)
8607
        return NULL;
8608
    result = _PyUnicode_EncodeCharmap(unicode, mapping, errors);
inline
             
_PyUnicode_EncodeCharmap too costly to inline (cost=640, threshold=625) 
PyUnicode_EncodeCharmap
inline
             
_PyUnicode_EncodeCharmap will not be inlined into PyUnicode_EncodeCharmap 
PyUnicode_EncodeCharmap
8609
    Py_DECREF(unicode);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeCharmap
8610
    return result;
8611
}
8612
8613
PyObject *
8614
PyUnicode_AsCharmapString(PyObject *unicode,
8615
                          PyObject *mapping)
8616
{
8617
    if (!PyUnicode_Check(unicode) || mapping == NULL) {
8618
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_AsCharmapString because its definition is unavailable 
PyUnicode_AsCharmapString
8619
        return NULL;
8620
    }
8621
    return _PyUnicode_EncodeCharmap(unicode, mapping, NULL);
inline
           
_PyUnicode_EncodeCharmap too costly to inline (cost=640, threshold=625) 
PyUnicode_AsCharmapString
inline
           
_PyUnicode_EncodeCharmap will not be inlined into PyUnicode_AsCharmapString 
PyUnicode_AsCharmapString
8622
}
8623
8624
/* create or adjust a UnicodeTranslateError */
8625
static void
8626
make_translate_exception(PyObject **exceptionObject,
8627
                         PyObject *unicode,
8628
                         Py_ssize_t startpos, Py_ssize_t endpos,
8629
                         const char *reason)
8630
{
8631
    if (*exceptionObject == NULL) {
gvn
        
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_translate_call_errorhandler
8632
        *exceptionObject = _PyUnicodeTranslateError_Create(
inline
                           
_PyUnicodeTranslateError_Create will not be inlined into make_translate_exception because its definition is unavailable 
make_translate_exception
8633
            unicode, startpos, endpos, reason);
8634
    }
8635
    else {
8636
        if (PyUnicodeTranslateError_SetStart(*exceptionObject, startpos))
inline
            
PyUnicodeTranslateError_SetStart will not be inlined into make_translate_exception because its definition is unavailable 
make_translate_exception
8637
            goto onError;
8638
        if (PyUnicodeTranslateError_SetEnd(*exceptionObject, endpos))
inline
            
PyUnicodeTranslateError_SetEnd will not be inlined into make_translate_exception because its definition is unavailable 
make_translate_exception
gvn
                                           
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
make_translate_exception
gvn
                                           
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_translate_call_errorhandler
8639
            goto onError;
8640
        if (PyUnicodeTranslateError_SetReason(*exceptionObject, reason))
inline
            
PyUnicodeTranslateError_SetReason will not be inlined into make_translate_exception because its definition is unavailable 
make_translate_exception
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
make_translate_exception
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_translate_call_errorhandler
8641
            goto onError;
8642
        return;
8643
      onError:
8644
        Py_CLEAR(*exceptionObject);
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
make_translate_exception
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
make_translate_exception
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
make_translate_exception
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
make_translate_exception
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_translate_call_errorhandler
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8645
    }
8646
}
8647
8648
/* error handling callback helper:
8649
   build arguments, call the callback and check the arguments,
8650
   put the result into newpos and return the replacement string, which
8651
   has to be freed by the caller */
8652
static PyObject *
8653
unicode_translate_call_errorhandler(const char *errors,
8654
                                    PyObject **errorHandler,
8655
                                    const char *reason,
8656
                                    PyObject *unicode, PyObject **exceptionObject,
8657
                                    Py_ssize_t startpos, Py_ssize_t endpos,
8658
                                    Py_ssize_t *newpos)
8659
{
8660
    static const char *argparse = "O!n;translating error handler must return (str, int) tuple";
8661
8662
    Py_ssize_t i_newpos;
licm
    
hosting bitcast 
_PyUnicode_TranslateCharmap
8663
    PyObject *restuple;
8664
    PyObject *resunicode;
licm
    
hosting bitcast 
_PyUnicode_TranslateCharmap
8665
8666
    if (*errorHandler == NULL) {
8667
        *errorHandler = PyCodec_LookupError(errors);
inline
                        
PyCodec_LookupError will not be inlined into unicode_translate_call_errorhandler because its definition is unavailable 
unicode_translate_call_errorhandler
8668
        if (*errorHandler == NULL)
8669
            return NULL;
8670
    }
8671
8672
    make_translate_exception(exceptionObject,
inline
    
make_translate_exception can be inlined into unicode_translate_call_errorhandler with cost=-14755 (threshold=250) 
unicode_translate_call_errorhandler
inline
    
make_translate_exception inlined into unicode_translate_call_errorhandler 
unicode_translate_call_errorhandler
8673
                             unicode, startpos, endpos, reason);
8674
    if (*exceptionObject == NULL)
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_translate_call_errorhandler
8675
        return NULL;
8676
8677
    restuple = PyObject_CallFunctionObjArgs(
inline
               
PyObject_CallFunctionObjArgs will not be inlined into unicode_translate_call_errorhandler because its definition is unavailable 
unicode_translate_call_errorhandler
8678
        *errorHandler, *exceptionObject, NULL);
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by store 
unicode_translate_call_errorhandler
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by store 
unicode_translate_call_errorhandler
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_translate_call_errorhandler
8679
    if (restuple == NULL)
8680
        return NULL;
8681
    if (!PyTuple_Check(restuple)) {
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8682
        PyErr_SetString(PyExc_TypeError, &argparse[4]);
inline
        
PyErr_SetString will not be inlined into unicode_translate_call_errorhandler because its definition is unavailable 
unicode_translate_call_errorhandler
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8683
        Py_DECREF(restuple);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
8684
        return NULL;
8685
    }
8686
    if (!PyArg_ParseTuple(restuple, argparse, &PyUnicode_Type,
inline
         
_PyArg_ParseTuple_SizeT will not be inlined into unicode_translate_call_errorhandler because its definition is unavailable 
unicode_translate_call_errorhandler
8687
                          &resunicode, &i_newpos)) {
8688
        Py_DECREF(restuple);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
8689
        return NULL;
8690
    }
8691
    if (i_newpos<0)
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_translate_call_errorhandler
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_TranslateCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8692
        *newpos = PyUnicode_GET_LENGTH(unicode)+i_newpos;
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
unicode_translate_call_errorhandler
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_TranslateCharmap
gvn
                  
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
8693
    else
8694
        *newpos = i_newpos;
8695
    if (*newpos<0 || *newpos>PyUnicode_GET_LENGTH(unicode)) {
gvn
                             
load of type i64 not eliminated because it is clobbered by store 
unicode_translate_call_errorhandler
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_TranslateCharmap
gvn
                             
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                             
load eliminated by PRE 
_PyUnicode_TranslateCharmap
8696
        PyErr_Format(PyExc_IndexError, "position %zd from error handler out of bounds", *newpos);
inline
        
PyErr_Format will not be inlined into unicode_translate_call_errorhandler because its definition is unavailable 
unicode_translate_call_errorhandler
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8697
        Py_DECREF(restuple);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
8698
        return NULL;
8699
    }
8700
    Py_INCREF(resunicode);
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_translate_call_errorhandler
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8701
    Py_DECREF(restuple);
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_translate_call_errorhandler
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
    
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
8702
    return resunicode;
gvn
           
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_translate_call_errorhandler
gvn
           
load eliminated by PRE 
unicode_translate_call_errorhandler
8703
}
8704
8705
/* Lookup the character ch in the mapping and put the result in result,
8706
   which must be decrefed by the caller.
8707
   Return 0 on success, -1 on error */
8708
static int
8709
charmaptranslate_lookup(Py_UCS4 c, PyObject *mapping, PyObject **result)
8710
{
8711
    PyObject *w = PyLong_FromLong((long)c);
inline
                  
PyLong_FromLong will not be inlined into charmaptranslate_lookup because its definition is unavailable 
charmaptranslate_lookup
8712
    PyObject *x;
8713
8714
    if (w == NULL)
8715
        return -1;
8716
    x = PyObject_GetItem(mapping, w);
inline
        
PyObject_GetItem will not be inlined into charmaptranslate_lookup because its definition is unavailable 
charmaptranslate_lookup
8717
    Py_DECREF(w);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
charmaptranslate_lookup
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmaptranslate_lookup
8718
    if (x == NULL) {
8719
        if (PyErr_ExceptionMatches(PyExc_LookupError)) {
inline
            
PyErr_ExceptionMatches will not be inlined into charmaptranslate_lookup because its definition is unavailable 
charmaptranslate_lookup
gvn
                                   
load of type %struct._object* not eliminated because it is clobbered by call 
charmaptranslate_lookup
gvn
                                   
load of type %struct._object* not eliminated because it is clobbered by call 
charmaptranslate_lookup
8720
            /* No mapping found means: use 1:1 mapping. */
8721
            PyErr_Clear();
inline
            
PyErr_Clear will not be inlined into charmaptranslate_lookup because its definition is unavailable 
charmaptranslate_lookup
8722
            *result = NULL;
8723
            return 0;
8724
        } else
8725
            return -1;
8726
    }
8727
    else if (x == Py_None) {
8728
        *result = x;
8729
        return 0;
8730
    }
8731
    else if (PyLong_Check(x)) {
gvn
             
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmaptranslate_lookup
gvn
             
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmaptranslate_lookup
8732
        long value = PyLong_AS_LONG(x);
inline
                     
PyLong_AsLong will not be inlined into charmaptranslate_lookup because its definition is unavailable 
charmaptranslate_lookup
8733
        if (value < 0 || value > MAX_UNICODE) {
8734
            PyErr_Format(PyExc_ValueError,
inline
            
PyErr_Format will not be inlined into charmaptranslate_lookup because its definition is unavailable 
charmaptranslate_lookup
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
charmaptranslate_lookup
8735
                         "character mapping must be in range(0x%x)",
8736
                         MAX_UNICODE+1);
8737
            Py_DECREF(x);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
charmaptranslate_lookup
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmaptranslate_lookup
8738
            return -1;
8739
        }
8740
        *result = x;
8741
        return 0;
8742
    }
8743
    else if (PyUnicode_Check(x)) {
8744
        *result = x;
8745
        return 0;
8746
    }
8747
    else {
8748
        /* wrong return value */
8749
        PyErr_SetString(PyExc_TypeError,
inline
        
PyErr_SetString will not be inlined into charmaptranslate_lookup because its definition is unavailable 
charmaptranslate_lookup
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
charmaptranslate_lookup
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
charmaptranslate_lookup
8750
                        "character mapping must return integer, None or str");
8751
        Py_DECREF(x);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmaptranslate_lookup
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmaptranslate_lookup
8752
        return -1;
8753
    }
8754
}
8755
8756
/* lookup the character, write the result into the writer.
8757
   Return 1 if the result was written into the writer, return 0 if the mapping
8758
   was undefined, raise an exception return -1 on error. */
8759
static int
8760
charmaptranslate_output(Py_UCS4 ch, PyObject *mapping,
8761
                        _PyUnicodeWriter *writer)
8762
{
8763
    PyObject *item;
licm
    
hosting bitcast 
_PyUnicode_TranslateCharmap
8764
8765
    if (charmaptranslate_lookup(ch, mapping, &item))
inline
        
charmaptranslate_lookup too costly to inline (cost=455, threshold=250) 
charmaptranslate_output
inline
        
charmaptranslate_lookup will not be inlined into charmaptranslate_output 
charmaptranslate_output
inline
        
charmaptranslate_lookup too costly to inline (cost=455, threshold=250) 
_PyUnicode_TranslateCharmap
inline
        
charmaptranslate_lookup will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
8766
        return -1;
8767
8768
    if (item == NULL) {
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
charmaptranslate_output
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_TranslateCharmap
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8769
        /* not found => default to 1:1 mapping */
8770
        if (_PyUnicodeWriter_WriteCharInline(writer, ch) < 0) {
inline
            
_PyUnicodeWriter_WriteCharInline can be inlined into charmaptranslate_output with cost=150 (threshold=325) 
charmaptranslate_output
inline
            
_PyUnicodeWriter_WriteCharInline inlined into charmaptranslate_output 
charmaptranslate_output
8771
            return -1;
8772
        }
8773
        return 1;
8774
    }
8775
8776
    if (item == Py_None) {
8777
        Py_DECREF(item);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
charmaptranslate_output
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_TranslateCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8778
        return 0;
8779
    }
8780
8781
    if (PyLong_Check(item)) {
8782
        long ch = (Py_UCS4)PyLong_AS_LONG(item);
inline
                           
PyLong_AsLong will not be inlined into charmaptranslate_output because its definition is unavailable 
charmaptranslate_output
8783
        /* PyLong_AS_LONG() cannot fail, charmaptranslate_lookup() already
8784
           used it */
8785
        if (_PyUnicodeWriter_WriteCharInline(writer, ch) < 0) {
inline
            
_PyUnicodeWriter_WriteCharInline can be inlined into charmaptranslate_output with cost=150 (threshold=325) 
charmaptranslate_output
inline
            
_PyUnicodeWriter_WriteCharInline inlined into charmaptranslate_output 
charmaptranslate_output
8786
            Py_DECREF(item);
gvn
            
load of type %struct._object* eliminated in favor of load 
charmaptranslate_output
gvn
            
load of type i64 not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
            
load of type i64 not eliminated because it is clobbered by store 
charmaptranslate_output
gvn
            
load of type i64 not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by store 
charmaptranslate_output
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmaptranslate_output
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmaptranslate_output
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
8787
            return -1;
8788
        }
8789
        Py_DECREF(item);
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by store 
charmaptranslate_output
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmaptranslate_output
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmaptranslate_output
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
8790
        return 1;
8791
    }
8792
8793
    if (!PyUnicode_Check(item)) {
8794
        Py_DECREF(item);
8795
        return -1;
8796
    }
8797
8798
    if (_PyUnicodeWriter_WriteStr(writer, item) < 0) {
inline
        
_PyUnicodeWriter_WriteStr too costly to inline (cost=445, threshold=250) 
charmaptranslate_output
inline
        
_PyUnicodeWriter_WriteStr will not be inlined into charmaptranslate_output 
charmaptranslate_output
inline
        
_PyUnicodeWriter_WriteStr too costly to inline (cost=445, threshold=250) 
_PyUnicode_TranslateCharmap
inline
        
_PyUnicodeWriter_WriteStr will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
8799
        Py_DECREF(item);
gvn
        
load of type %struct._object* eliminated in favor of load 
charmaptranslate_output
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmaptranslate_output
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
8800
        return -1;
8801
    }
8802
8803
    Py_DECREF(item);
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
charmaptranslate_output
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
8804
    return 1;
8805
}
8806
8807
static int
8808
unicode_fast_translate_lookup(PyObject *mapping, Py_UCS1 ch,
8809
                              Py_UCS1 *translate)
8810
{
8811
    PyObject *item = NULL;
licm
    
hosting bitcast 
unicode_fast_translate
8812
    int ret = 0;
8813
8814
    if (charmaptranslate_lookup(ch, mapping, &item)) {
inline
        
charmaptranslate_lookup too costly to inline (cost=455, threshold=250) 
unicode_fast_translate_lookup
inline
        
charmaptranslate_lookup will not be inlined into unicode_fast_translate_lookup 
unicode_fast_translate_lookup
inline
        
charmaptranslate_lookup too costly to inline (cost=455, threshold=250) 
unicode_fast_translate
inline
        
charmaptranslate_lookup will not be inlined into unicode_fast_translate 
unicode_fast_translate
inline
        
charmaptranslate_lookup too costly to inline (cost=455, threshold=250) 
_PyUnicode_TranslateCharmap
inline
        
charmaptranslate_lookup will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
8815
        return -1;
8816
    }
8817
8818
    if (item == Py_None) {
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_fast_translate_lookup
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_fast_translate
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_fast_translate
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_TranslateCharmap
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
_PyUnicode_TranslateCharmap
8819
        /* deletion */
8820
        translate[ch] = 0xfe;
8821
    }
8822
    else if (item == NULL) {
8823
        /* not found => default to 1:1 mapping */
8824
        translate[ch] = ch;
8825
        return 1;
8826
    }
8827
    else if (PyLong_Check(item)) {
8828
        long replace = PyLong_AS_LONG(item);
inline
                       
PyLong_AsLong will not be inlined into unicode_fast_translate_lookup because its definition is unavailable 
unicode_fast_translate_lookup
8829
        /* PyLong_AS_LONG() cannot fail, charmaptranslate_lookup() already
8830
           used it */
8831
        if (127 < replace) {
8832
            /* invalid character or character outside ASCII:
8833
               skip the fast translate */
8834
            goto exit;
8835
        }
8836
        translate[ch] = (Py_UCS1)replace;
8837
    }
8838
    else if (PyUnicode_Check(item)) {
8839
        Py_UCS4 replace;
8840
8841
        if (PyUnicode_READY(item) == -1) {
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_fast_translate_lookup
inline
            
_PyUnicode_Ready will not be inlined into unicode_fast_translate_lookup 
unicode_fast_translate_lookup
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_fast_translate
inline
            
_PyUnicode_Ready will not be inlined into unicode_fast_translate 
unicode_fast_translate
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_TranslateCharmap
inline
            
_PyUnicode_Ready will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
8842
            Py_DECREF(item);
gvn
            
load of type %struct._object* eliminated in favor of load 
unicode_fast_translate_lookup
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fast_translate_lookup
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_fast_translate_lookup
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fast_translate
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_fast_translate
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
8843
            return -1;
8844
        }
8845
        if (PyUnicode_GET_LENGTH(item) != 1)
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fast_translate_lookup
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_fast_translate
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8846
            goto exit;
8847
8848
        replace = PyUnicode_READ_CHAR(item, 0);
gvn
                  
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_fast_translate_lookup
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
unicode_fast_translate_lookup
gvn
                  
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_fast_translate
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
unicode_fast_translate
gvn
                  
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8849
        if (replace > 127)
8850
            goto exit;
8851
        translate[ch] = (Py_UCS1)replace;
8852
    }
8853
    else {
8854
        /* not None, NULL, long or unicode */
8855
        goto exit;
8856
    }
8857
    ret = 1;
8858
8859
  exit:
8860
    Py_DECREF(item);
gvn
    
load of type %struct._object* eliminated in favor of load 
unicode_fast_translate_lookup
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_fast_translate_lookup
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_fast_translate_lookup
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_fast_translate_lookup
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_fast_translate_lookup
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_fast_translate_lookup
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_fast_translate_lookup
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_fast_translate_lookup
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_fast_translate_lookup
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_fast_translate_lookup
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_fast_translate_lookup
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_fast_translate
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_fast_translate
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_fast_translate
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_fast_translate
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8861
    return ret;
8862
}
8863
8864
/* Fast path for ascii => ascii translation. Return 1 if the whole string
8865
   was translated into writer, return 0 if the input string was partially
8866
   translated into writer, raise an exception and return -1 on error. */
8867
static int
8868
unicode_fast_translate(PyObject *input, PyObject *mapping,
8869
                       _PyUnicodeWriter *writer, int ignore,
8870
                       Py_ssize_t *input_pos)
8871
{
8872
    Py_UCS1 ascii_table[128], ch, ch2;
8873
    Py_ssize_t len;
8874
    Py_UCS1 *in, *end, *out;
8875
    int res = 0;
8876
8877
    len = PyUnicode_GET_LENGTH(input);
gvn
          
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
          
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
8878
8879
    memset(ascii_table, 0xff, 128);
8880
8881
    in = PyUnicode_1BYTE_DATA(input);
gvn
         
load of type i32 eliminated in favor of phi 
_PyUnicode_TranslateCharmap
gvn
         
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
         
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
         
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8882
    end = in + len;
8883
8884
    assert(PyUnicode_IS_ASCII(writer->buffer));
8885
    assert(PyUnicode_GET_LENGTH(writer->buffer) == len);
8886
    out = PyUnicode_1BYTE_DATA(writer->buffer);
gvn
          
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8887
8888
    for (; in < end; in++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_TranslateCharmap
loop-vectorize
    
loop not vectorized 
_PyUnicode_TranslateCharmap
8889
        ch = *in;
gvn
             
load of type i8 not eliminated because it is clobbered by call 
unicode_fast_translate
gvn
             
load of type i8 not eliminated because it is clobbered by store 
unicode_fast_translate
gvn
             
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
             
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
             
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
             
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
             
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8890
        ch2 = ascii_table[ch];
8891
        if (ch2 == 0xff) {
8892
            int translate = unicode_fast_translate_lookup(mapping, ch,
inline
                            
unicode_fast_translate_lookup can be inlined into unicode_fast_translate with cost=-14495 (threshold=250) 
unicode_fast_translate
inline
                            
unicode_fast_translate_lookup inlined into unicode_fast_translate 
unicode_fast_translate
8893
                                                          ascii_table);
8894
            if (translate < 0)
8895
                return -1;
8896
            if (translate == 0)
8897
                goto exit;
8898
            ch2 = ascii_table[ch];
gvn
                  
load of type i8 eliminated in favor of phi 
unicode_fast_translate
8899
        }
8900
        if (ch2 == 0xfe) {
8901
            if (ignore)
licm
                
hosting icmp 
unicode_fast_translate
8902
                continue;
8903
            goto exit;
8904
        }
8905
        assert(ch2 < 128);
8906
        *out = ch2;
8907
        out++;
8908
    }
8909
    res = 1;
8910
8911
exit:
8912
    writer->pos = out - PyUnicode_1BYTE_DATA(writer->buffer);
gvn
                        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_fast_translate
gvn
                        
load of type %struct._object* not eliminated in favor of load because it is clobbered by store 
unicode_fast_translate
gvn
                        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_fast_translate
gvn
                        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_fast_translate
gvn
                        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_fast_translate
gvn
                        
load eliminated by PRE 
unicode_fast_translate
8913
    *input_pos = in - PyUnicode_1BYTE_DATA(input);
gvn
                      
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_fast_translate
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
unicode_fast_translate
gvn
                      
load of type i8* not eliminated because it is clobbered by store 
unicode_fast_translate
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
unicode_fast_translate
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
unicode_fast_translate
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
unicode_fast_translate
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                      
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
8914
    return res;
8915
}
8916
8917
static PyObject *
8918
_PyUnicode_TranslateCharmap(PyObject *input,
8919
                            PyObject *mapping,
8920
                            const char *errors)
8921
{
8922
    /* input object */
8923
    char *data;
8924
    Py_ssize_t size, i;
8925
    int kind;
8926
    /* output buffer */
8927
    _PyUnicodeWriter writer;
8928
    /* error handler */
8929
    char *reason = "character maps to <undefined>";
8930
    PyObject *errorHandler = NULL;
8931
    PyObject *exc = NULL;
8932
    int ignore;
8933
    int res;
8934
8935
    if (mapping == NULL) {
8936
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into _PyUnicode_TranslateCharmap because its definition is unavailable 
_PyUnicode_TranslateCharmap
8937
        return NULL;
8938
    }
8939
8940
    if (PyUnicode_READY(input) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_TranslateCharmap
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
8941
        return NULL;
8942
    data = (char*)PyUnicode_DATA(input);
gvn
                  
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                  
load eliminated by PRE 
_PyUnicode_TranslateCharmap
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8943
    kind = PyUnicode_KIND(input);
8944
    size = PyUnicode_GET_LENGTH(input);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8945
8946
    if (size == 0)
8947
        return PyUnicode_FromObject(input);
inline
               
PyUnicode_FromObject can be inlined into _PyUnicode_TranslateCharmap with cost=165 (threshold=250) 
_PyUnicode_TranslateCharmap
inline
               
PyUnicode_FromObject inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
8948
8949
    /* allocate enough for a simple 1:1 translation without
8950
       replacements, if we need more, we'll resize */
8951
    _PyUnicodeWriter_Init(&writer);
inline
    
_PyUnicodeWriter_Init can be inlined into _PyUnicode_TranslateCharmap with cost=-30 (threshold=375) 
_PyUnicode_TranslateCharmap
inline
    
_PyUnicodeWriter_Init inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
8952
    if (_PyUnicodeWriter_Prepare(&writer, size, 127) == -1)
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
_PyUnicode_TranslateCharmap
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
gvn
        
load of type i32 eliminated in favor of 0 
_PyUnicode_TranslateCharmap
8953
        goto onError;
8954
8955
    ignore = (errors != NULL && strcmp(errors, "ignore") == 0);
inline
                                
strcmp will not be inlined into _PyUnicode_TranslateCharmap because its definition is unavailable 
_PyUnicode_TranslateCharmap
8956
8957
    if (PyUnicode_READY(input) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_TranslateCharmap
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
8958
        return NULL;
8959
    if (PyUnicode_IS_ASCII(input)) {
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load eliminated by PRE 
_PyUnicode_TranslateCharmap
8960
        res = unicode_fast_translate(input, mapping, &writer, ignore, &i);
inline
              
unicode_fast_translate can be inlined into _PyUnicode_TranslateCharmap with cost=-14270 (threshold=250) 
_PyUnicode_TranslateCharmap
inline
              
unicode_fast_translate inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
8961
        if (res < 0) {
8962
            _PyUnicodeWriter_Dealloc(&writer);
inline
            
_PyUnicodeWriter_Dealloc can be inlined into _PyUnicode_TranslateCharmap with cost=20 (threshold=250) 
_PyUnicode_TranslateCharmap
inline
            
_PyUnicodeWriter_Dealloc inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
8963
            return NULL;
8964
        }
8965
        if (res == 1)
8966
            return _PyUnicodeWriter_Finish(&writer);
inline
                   
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
_PyUnicode_TranslateCharmap
inline
                   
_PyUnicodeWriter_Finish will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
8967
    }
8968
    else {
8969
        i = 0;
8970
    }
8971
8972
    while (i<size) {
licm
            
hosting icmp 
_PyUnicode_TranslateCharmap
8973
        /* try to encode it */
8974
        int translate;
8975
        PyObject *repunicode = NULL; /* initialize to prevent gcc warning */
8976
        Py_ssize_t newpos;
8977
        /* startpos for collecting untranslatable chars */
8978
        Py_ssize_t collstart;
8979
        Py_ssize_t collend;
8980
        Py_UCS4 ch;
8981
8982
        ch = PyUnicode_READ(kind, data, i);
licm
             
hosting icmp 
_PyUnicode_TranslateCharmap
licm
             
hosting getelementptr 
_PyUnicode_TranslateCharmap
licm
             
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_TranslateCharmap
licm
             
hosting bitcast 
_PyUnicode_TranslateCharmap
gvn
             
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
             
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
             
load of type i16 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
             
load of type i16 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
             
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
             
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
             
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
8983
        translate = charmaptranslate_output(ch, mapping, &writer);
inline
                    
charmaptranslate_output can be inlined into _PyUnicode_TranslateCharmap with cost=-14210 (threshold=250) 
_PyUnicode_TranslateCharmap
inline
                    
charmaptranslate_output inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
8984
        if (translate < 0)
8985
            goto onError;
8986
8987
        if (translate != 0) {
8988
            /* it worked => adjust input pointer */
8989
            ++i;
licm
            
hosting add 
_PyUnicode_TranslateCharmap
8990
            continue;
8991
        }
8992
8993
        /* untranslatable character */
8994
        collstart = i;
8995
        collend = i+1;
8996
8997
        /* find all untranslatable characters */
8998
        while (collend < size) {
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_TranslateCharmap
loop-vectorize
        
loop not vectorized 
_PyUnicode_TranslateCharmap
8999
            PyObject *x;
licm
            
hosting bitcast 
_PyUnicode_TranslateCharmap
9000
            ch = PyUnicode_READ(kind, data, collend);
licm
                 
hosting icmp 
_PyUnicode_TranslateCharmap
licm
                 
hosting bitcast 
_PyUnicode_TranslateCharmap
9001
            if (charmaptranslate_lookup(ch, mapping, &x))
inline
                
charmaptranslate_lookup too costly to inline (cost=455, threshold=250) 
_PyUnicode_TranslateCharmap
inline
                
charmaptranslate_lookup will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
9002
                goto onError;
9003
            Py_XDECREF(x);
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_TranslateCharmap
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
9004
            if (x != Py_None)
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_TranslateCharmap
gvn
                
load of type %struct._object* eliminated in favor of load 
_PyUnicode_TranslateCharmap
9005
                break;
9006
            ++collend;
9007
        }
9008
9009
        if (ignore) {
9010
            i = collend;
9011
        }
9012
        else {
9013
            repunicode = unicode_translate_call_errorhandler(errors, &errorHandler,
inline
                         
unicode_translate_call_errorhandler can be inlined into _PyUnicode_TranslateCharmap with cost=-14230 (threshold=250) 
_PyUnicode_TranslateCharmap
inline
                         
unicode_translate_call_errorhandler inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
9014
                                                             reason, input, &exc,
9015
                                                             collstart, collend, &newpos);
9016
            if (repunicode == NULL)
9017
                goto onError;
9018
            if (_PyUnicodeWriter_WriteStr(&writer, repunicode) < 0) {
inline
                
_PyUnicodeWriter_WriteStr too costly to inline (cost=445, threshold=250) 
_PyUnicode_TranslateCharmap
inline
                
_PyUnicodeWriter_WriteStr will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
9019
                Py_DECREF(repunicode);
gvn
                
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
                
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
9020
                goto onError;
9021
            }
9022
            Py_DECREF(repunicode);
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
9023
            i = newpos;
9024
        }
9025
    }
9026
    Py_XDECREF(exc);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
9027
    Py_XDECREF(errorHandler);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
9028
    return _PyUnicodeWriter_Finish(&writer);
inline
           
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
_PyUnicode_TranslateCharmap
inline
           
_PyUnicodeWriter_Finish will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
9029
9030
  onError:
9031
    _PyUnicodeWriter_Dealloc(&writer);
inline
    
_PyUnicodeWriter_Dealloc can be inlined into _PyUnicode_TranslateCharmap with cost=20 (threshold=250) 
_PyUnicode_TranslateCharmap
inline
    
_PyUnicodeWriter_Dealloc inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
9032
    Py_XDECREF(exc);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
9033
    Py_XDECREF(errorHandler);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
9034
    return NULL;
9035
}
9036
9037
/* Deprecated. Use PyUnicode_Translate instead. */
9038
PyObject *
9039
PyUnicode_TranslateCharmap(const Py_UNICODE *p,
9040
                           Py_ssize_t size,
9041
                           PyObject *mapping,
9042
                           const char *errors)
9043
{
9044
    PyObject *result;
9045
    PyObject *unicode = PyUnicode_FromUnicode(p, size);
inline
                        
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_TranslateCharmap
inline
                        
PyUnicode_FromUnicode will not be inlined into PyUnicode_TranslateCharmap 
PyUnicode_TranslateCharmap
9046
    if (!unicode)
9047
        return NULL;
9048
    result = _PyUnicode_TranslateCharmap(unicode, mapping, errors);
inline
             
_PyUnicode_TranslateCharmap too costly to inline (cost=650, threshold=625) 
PyUnicode_TranslateCharmap
inline
             
_PyUnicode_TranslateCharmap will not be inlined into PyUnicode_TranslateCharmap 
PyUnicode_TranslateCharmap
9049
    Py_DECREF(unicode);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_TranslateCharmap
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_TranslateCharmap
9050
    return result;
9051
}
9052
9053
PyObject *
9054
PyUnicode_Translate(PyObject *str,
9055
                    PyObject *mapping,
9056
                    const char *errors)
9057
{
9058
    if (ensure_unicode(str) < 0)
inline
        
ensure_unicode can be inlined into PyUnicode_Translate with cost=95 (threshold=250) 
PyUnicode_Translate
inline
        
ensure_unicode inlined into PyUnicode_Translate 
PyUnicode_Translate
9059
        return NULL;
9060
    return _PyUnicode_TranslateCharmap(str, mapping, errors);
inline
           
_PyUnicode_TranslateCharmap too costly to inline (cost=650, threshold=625) 
PyUnicode_Translate
inline
           
_PyUnicode_TranslateCharmap will not be inlined into PyUnicode_Translate 
PyUnicode_Translate
9061
}
9062
9063
static Py_UCS4
9064
fix_decimal_and_space_to_ascii(PyObject *self)
9065
{
9066
    /* No need to call PyUnicode_READY(self) because this function is only
9067
       called as a callback from fixup() which does it already. */
9068
    const Py_ssize_t len = PyUnicode_GET_LENGTH(self);
9069
    const int kind = PyUnicode_KIND(self);
9070
    void *data = PyUnicode_DATA(self);
9071
    Py_UCS4 maxchar = 127, ch, fixed;
9072
    int modified = 0;
9073
    Py_ssize_t i;
9074
9075
    for (i = 0; i < len; ++i) {
loop-vectorize
    
loop not vectorized 
fix_decimal_and_space_to_ascii
9076
        ch = PyUnicode_READ(kind, data, i);
licm
             
hosting trunc 
fix_decimal_and_space_to_ascii
licm
             
hosting bitcast 
fix_decimal_and_space_to_ascii
9077
        fixed = 0;
9078
        if (ch > 127) {
9079
            if (Py_UNICODE_ISSPACE(ch))
inline
                
_PyUnicode_IsWhitespace will not be inlined into fix_decimal_and_space_to_ascii because its definition is unavailable 
fix_decimal_and_space_to_ascii
loop-vectorize
                
loop not vectorized: control flow cannot be substituted for a select 
fix_decimal_and_space_to_ascii
9080
                fixed = ' ';
9081
            else {
9082
                const int decimal = Py_UNICODE_TODECIMAL(ch);
inline
                                    
_PyUnicode_ToDecimalDigit will not be inlined into fix_decimal_and_space_to_ascii because its definition is unavailable 
fix_decimal_and_space_to_ascii
9083
                if (decimal >= 0)
9084
                    fixed = '0' + decimal;
9085
            }
9086
            if (fixed != 0) {
9087
                modified = 1;
9088
                maxchar = Py_MAX(maxchar, fixed);
9089
                PyUnicode_WRITE(kind, data, i, fixed);
licm
                
hosting trunc 
fix_decimal_and_space_to_ascii
licm
                
hosting bitcast 
fix_decimal_and_space_to_ascii
9090
            }
9091
            else
9092
                maxchar = Py_MAX(maxchar, ch);
9093
        }
9094
    }
9095
9096
    return (modified) ? maxchar : 0;
9097
}
9098
9099
PyObject *
9100
_PyUnicode_TransformDecimalAndSpaceToASCII(PyObject *unicode)
9101
{
9102
    if (!PyUnicode_Check(unicode)) {
9103
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into _PyUnicode_TransformDecimalAndSpaceToASCII because its definition is unavailable 
_PyUnicode_TransformDecimalAndSpaceToASCII
9104
        return NULL;
9105
    }
9106
    if (PyUnicode_READY(unicode) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_TransformDecimalAndSpaceToASCII
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_TransformDecimalAndSpaceToASCII 
_PyUnicode_TransformDecimalAndSpaceToASCII
9107
        return NULL;
9108
    if (PyUnicode_MAX_CHAR_VALUE(unicode) <= 127) {
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
gvn
        
load eliminated by PRE 
_PyUnicode_TransformDecimalAndSpaceToASCII
9109
        /* If the string is already ASCII, just return the same string */
9110
        Py_INCREF(unicode);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
9111
        return unicode;
9112
    }
9113
    return fixup(unicode, fix_decimal_and_space_to_ascii);
inline
           
fixup can be inlined into _PyUnicode_TransformDecimalAndSpaceToASCII with cost=-14465 (threshold=250) 
_PyUnicode_TransformDecimalAndSpaceToASCII
inline
           
fixup inlined into _PyUnicode_TransformDecimalAndSpaceToASCII 
_PyUnicode_TransformDecimalAndSpaceToASCII
9114
}
9115
9116
PyObject *
9117
PyUnicode_TransformDecimalToASCII(Py_UNICODE *s,
9118
                                  Py_ssize_t length)
9119
{
9120
    PyObject *decimal;
9121
    Py_ssize_t i;
9122
    Py_UCS4 maxchar;
9123
    enum PyUnicode_Kind kind;
9124
    void *data;
9125
9126
    maxchar = 127;
9127
    for (i = 0; i < length; i++) {
loop-vectorize
    
loop not vectorized 
PyUnicode_TransformDecimalToASCII
9128
        Py_UCS4 ch = s[i];
9129
        if (ch > 127) {
9130
            int decimal = Py_UNICODE_TODECIMAL(ch);
inline
                          
_PyUnicode_ToDecimalDigit will not be inlined into PyUnicode_TransformDecimalToASCII because its definition is unavailable 
PyUnicode_TransformDecimalToASCII
9131
            if (decimal >= 0)
9132
                ch = '0' + decimal;
9133
            maxchar = Py_MAX(maxchar, ch);
9134
        }
loop-vectorize
        
loop not vectorized: control flow cannot be substituted for a select 
PyUnicode_TransformDecimalToASCII
9135
    }
9136
9137
    /* Copy to a new string */
9138
    decimal = PyUnicode_New(length, maxchar);
inline
              
PyUnicode_New too costly to inline (cost=460, threshold=250) 
PyUnicode_TransformDecimalToASCII
inline
              
PyUnicode_New will not be inlined into PyUnicode_TransformDecimalToASCII 
PyUnicode_TransformDecimalToASCII
9139
    if (decimal == NULL)
9140
        return decimal;
9141
    kind = PyUnicode_KIND(decimal);
gvn
           
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_TransformDecimalToASCII
9142
    data = PyUnicode_DATA(decimal);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_TransformDecimalToASCII
9143
    /* Iterate over code points */
9144
    for (i = 0; i < length; i++) {
loop-vectorize
    
loop not vectorized 
PyUnicode_TransformDecimalToASCII
9145
        Py_UCS4 ch = s[i];
gvn
                     
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_TransformDecimalToASCII
9146
        if (ch > 127) {
9147
            int decimal = Py_UNICODE_TODECIMAL(ch);
inline
                          
_PyUnicode_ToDecimalDigit will not be inlined into PyUnicode_TransformDecimalToASCII because its definition is unavailable 
PyUnicode_TransformDecimalToASCII
9148
            if (decimal >= 0)
9149
                ch = '0' + decimal;
9150
        }
loop-vectorize
        
loop not vectorized: control flow cannot be substituted for a select 
PyUnicode_TransformDecimalToASCII
9151
        PyUnicode_WRITE(kind, data, i, ch);
licm
        
hosting trunc 
PyUnicode_TransformDecimalToASCII
licm
        
hosting bitcast 
PyUnicode_TransformDecimalToASCII
9152
    }
9153
    return unicode_result(decimal);
inline
           
unicode_result too costly to inline (cost=460, threshold=250) 
PyUnicode_TransformDecimalToASCII
inline
           
unicode_result will not be inlined into PyUnicode_TransformDecimalToASCII 
PyUnicode_TransformDecimalToASCII
9154
}
9155
/* --- Decimal Encoder ---------------------------------------------------- */
9156
9157
int
9158
PyUnicode_EncodeDecimal(Py_UNICODE *s,
9159
                        Py_ssize_t length,
9160
                        char *output,
9161
                        const char *errors)
9162
{
9163
    PyObject *unicode;
9164
    Py_ssize_t i;
9165
    enum PyUnicode_Kind kind;
9166
    void *data;
9167
9168
    if (output == NULL) {
9169
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_EncodeDecimal because its definition is unavailable 
PyUnicode_EncodeDecimal
9170
        return -1;
9171
    }
9172
9173
    unicode = PyUnicode_FromUnicode(s, length);
inline
              
PyUnicode_FromUnicode too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeDecimal
inline
              
PyUnicode_FromUnicode will not be inlined into PyUnicode_EncodeDecimal 
PyUnicode_EncodeDecimal
9174
    if (unicode == NULL)
9175
        return -1;
9176
9177
    if (PyUnicode_READY(unicode) == -1) {
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_EncodeDecimal
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_EncodeDecimal 
PyUnicode_EncodeDecimal
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_EncodeDecimal
9178
        Py_DECREF(unicode);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeDecimal
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeDecimal
9179
        return -1;
9180
    }
9181
    kind = PyUnicode_KIND(unicode);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_EncodeDecimal
gvn
           
load eliminated by PRE 
PyUnicode_EncodeDecimal
9182
    data = PyUnicode_DATA(unicode);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_EncodeDecimal
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_EncodeDecimal
9183
9184
    for (i=0; i < length; ) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_EncodeDecimal
loop-vectorize
    
loop not vectorized 
PyUnicode_EncodeDecimal
9185
        PyObject *exc;
9186
        Py_UCS4 ch;
9187
        int decimal;
9188
        Py_ssize_t startpos;
9189
9190
        ch = PyUnicode_READ(kind, data, i);
licm
             
hosting trunc 
PyUnicode_EncodeDecimal
licm
             
hosting bitcast 
PyUnicode_EncodeDecimal
9191
9192
        if (Py_UNICODE_ISSPACE(ch)) {
inline
            
_PyUnicode_IsWhitespace will not be inlined into PyUnicode_EncodeDecimal because its definition is unavailable 
PyUnicode_EncodeDecimal
9193
            *output++ = ' ';
9194
            i++;
9195
            continue;
9196
        }
9197
        decimal = Py_UNICODE_TODECIMAL(ch);
inline
                  
_PyUnicode_ToDecimalDigit will not be inlined into PyUnicode_EncodeDecimal because its definition is unavailable 
PyUnicode_EncodeDecimal
9198
        if (decimal >= 0) {
9199
            *output++ = '0' + decimal;
9200
            i++;
9201
            continue;
9202
        }
9203
        if (0 < ch && ch < 256) {
9204
            *output++ = (char)ch;
9205
            i++;
9206
            continue;
9207
        }
9208
9209
        startpos = i;
9210
        exc = NULL;
9211
        raise_encode_exception(&exc, "decimal", unicode,
inline
        
raise_encode_exception can be inlined into PyUnicode_EncodeDecimal with cost=-14950 (threshold=250) 
PyUnicode_EncodeDecimal
inline
        
raise_encode_exception inlined into PyUnicode_EncodeDecimal 
PyUnicode_EncodeDecimal
9212
                               startpos, startpos+1,
9213
                               "invalid decimal Unicode string");
9214
        Py_XDECREF(exc);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeDecimal
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeDecimal
9215
        Py_DECREF(unicode);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeDecimal
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_EncodeDecimal
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_EncodeDecimal
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeDecimal
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeDecimal
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_EncodeDecimal
9216
        return -1;
9217
    }
9218
    /* 0-terminate the output string */
9219
    *output++ = '\0';
9220
    Py_DECREF(unicode);
gvn
    
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_EncodeDecimal
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by store 
PyUnicode_EncodeDecimal
9221
    return 0;
9222
}
9223
9224
/* --- Helpers ------------------------------------------------------------ */
9225
9226
/* helper macro to fixup start/end slice values */
9227
#define ADJUST_INDICES(start, end, len)         \
9228
    if (end > len)                              \
9229
        end = len;                              \
9230
    else if (end < 0) {                         \
9231
        end += len;                             \
9232
        if (end < 0)                            \
9233
            end = 0;                            \
9234
    }                                           \
9235
    if (start < 0) {                            \
9236
        start += len;                           \
9237
        if (start < 0)                          \
9238
            start = 0;                          \
9239
    }
9240
9241
static Py_ssize_t
9242
any_find_slice(PyObject* s1, PyObject* s2,
9243
               Py_ssize_t start,
9244
               Py_ssize_t end,
9245
               int direction)
9246
{
9247
    int kind1, kind2;
9248
    void *buf1, *buf2;
9249
    Py_ssize_t len1, len2, result;
9250
9251
    kind1 = PyUnicode_KIND(s1);
9252
    kind2 = PyUnicode_KIND(s2);
9253
    if (kind1 < kind2)
9254
        return -1;
9255
9256
    len1 = PyUnicode_GET_LENGTH(s1);
9257
    len2 = PyUnicode_GET_LENGTH(s2);
9258
    ADJUST_INDICES(start, end, len1);
9259
    if (end - start < len2)
9260
        return -1;
9261
9262
    buf1 = PyUnicode_DATA(s1);
gvn
           
load of type i32 eliminated in favor of load 
any_find_slice
9263
    buf2 = PyUnicode_DATA(s2);
gvn
           
load of type i32 eliminated in favor of load 
any_find_slice
9264
    if (len2 == 1) {
9265
        Py_UCS4 ch = PyUnicode_READ(kind2, buf2, 0);
9266
        result = findchar((const char *)buf1 + kind1*start,
inline
                 
findchar can be inlined into any_find_slice with cost=295 (threshold=325) 
any_find_slice
inline
                 
findchar inlined into any_find_slice 
any_find_slice
9267
                          kind1, end - start, ch, direction);
9268
        if (result == -1)
9269
            return -1;
9270
        else
9271
            return start + result;
9272
    }
9273
9274
    if (kind2 != kind1) {
9275
        buf2 = _PyUnicode_AsKind(s2, kind1);
inline
               
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
any_find_slice
inline
               
_PyUnicode_AsKind will not be inlined into any_find_slice 
any_find_slice
9276
        if (!buf2)
9277
            return -2;
9278
    }
9279
9280
    if (direction > 0) {
9281
        switch (kind1) {
9282
        case PyUnicode_1BYTE_KIND:
9283
            if (PyUnicode_IS_ASCII(s1) && PyUnicode_IS_ASCII(s2))
gvn
                
load of type i32 not eliminated in favor of load because it is clobbered by call 
any_find_slice
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by call 
any_find_slice
9284
                result = asciilib_find_slice(buf1, len1, buf2, len2, start, end);
inline
                         
asciilib_find_slice can be inlined into any_find_slice with cost=-14960 (threshold=325) 
any_find_slice
inline
                         
asciilib_find_slice inlined into any_find_slice 
any_find_slice
9285
            else
9286
                result = ucs1lib_find_slice(buf1, len1, buf2, len2, start, end);
inline
                         
ucs1lib_find_slice can be inlined into any_find_slice with cost=-14960 (threshold=325) 
any_find_slice
inline
                         
ucs1lib_find_slice inlined into any_find_slice 
any_find_slice
9287
            break;
9288
        case PyUnicode_2BYTE_KIND:
9289
            result = ucs2lib_find_slice(buf1, len1, buf2, len2, start, end);
inline
                     
ucs2lib_find_slice can be inlined into any_find_slice with cost=-14960 (threshold=325) 
any_find_slice
inline
                     
ucs2lib_find_slice inlined into any_find_slice 
any_find_slice
9290
            break;
9291
        case PyUnicode_4BYTE_KIND:
9292
            result = ucs4lib_find_slice(buf1, len1, buf2, len2, start, end);
inline
                     
ucs4lib_find_slice can be inlined into any_find_slice with cost=-14960 (threshold=325) 
any_find_slice
inline
                     
ucs4lib_find_slice inlined into any_find_slice 
any_find_slice
9293
            break;
9294
        default:
9295
            assert(0); result = -2;
9296
        }
9297
    }
9298
    else {
9299
        switch (kind1) {
9300
        case PyUnicode_1BYTE_KIND:
9301
            if (PyUnicode_IS_ASCII(s1) && PyUnicode_IS_ASCII(s2))
gvn
                
load of type i32 not eliminated in favor of load because it is clobbered by call 
any_find_slice
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by call 
any_find_slice
9302
                result = asciilib_rfind_slice(buf1, len1, buf2, len2, start, end);
inline
                         
asciilib_rfind_slice can be inlined into any_find_slice with cost=-14960 (threshold=325) 
any_find_slice
inline
                         
asciilib_rfind_slice inlined into any_find_slice 
any_find_slice
9303
            else
9304
                result = ucs1lib_rfind_slice(buf1, len1, buf2, len2, start, end);
inline
                         
ucs1lib_rfind_slice can be inlined into any_find_slice with cost=-14960 (threshold=325) 
any_find_slice
inline
                         
ucs1lib_rfind_slice inlined into any_find_slice 
any_find_slice
9305
            break;
9306
        case PyUnicode_2BYTE_KIND:
9307
            result = ucs2lib_rfind_slice(buf1, len1, buf2, len2, start, end);
inline
                     
ucs2lib_rfind_slice can be inlined into any_find_slice with cost=-14960 (threshold=325) 
any_find_slice
inline
                     
ucs2lib_rfind_slice inlined into any_find_slice 
any_find_slice
9308
            break;
9309
        case PyUnicode_4BYTE_KIND:
9310
            result = ucs4lib_rfind_slice(buf1, len1, buf2, len2, start, end);
inline
                     
ucs4lib_rfind_slice can be inlined into any_find_slice with cost=-14960 (threshold=325) 
any_find_slice
inline
                     
ucs4lib_rfind_slice inlined into any_find_slice 
any_find_slice
9311
            break;
9312
        default:
9313
            assert(0); result = -2;
9314
        }
9315
    }
9316
9317
    if (kind2 != kind1)
9318
        PyMem_Free(buf2);
inline
        
PyMem_Free will not be inlined into any_find_slice because its definition is unavailable 
any_find_slice
9319
9320
    return result;
9321
}
9322
9323
Py_ssize_t
9324
_PyUnicode_InsertThousandsGrouping(
9325
    PyObject *unicode, Py_ssize_t index,
9326
    Py_ssize_t n_buffer,
9327
    void *digits, Py_ssize_t n_digits,
9328
    Py_ssize_t min_width,
9329
    const char *grouping, PyObject *thousands_sep,
9330
    Py_UCS4 *maxchar)
9331
{
9332
    unsigned int kind, thousands_sep_kind;
9333
    char *data, *thousands_sep_data;
9334
    Py_ssize_t thousands_sep_len;
9335
    Py_ssize_t len;
9336
9337
    if (unicode != NULL) {
9338
        kind = PyUnicode_KIND(unicode);
9339
        data = (char *) PyUnicode_DATA(unicode) + index * kind;
9340
    }
9341
    else {
9342
        kind = PyUnicode_1BYTE_KIND;
9343
        data = NULL;
9344
    }
9345
    thousands_sep_kind = PyUnicode_KIND(thousands_sep);
9346
    thousands_sep_data = PyUnicode_DATA(thousands_sep);
9347
    thousands_sep_len = PyUnicode_GET_LENGTH(thousands_sep);
9348
    if (unicode != NULL && thousands_sep_kind != kind) {
9349
        if (thousands_sep_kind < kind) {
9350
            thousands_sep_data = _PyUnicode_AsKind(thousands_sep, kind);
inline
                                 
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
_PyUnicode_InsertThousandsGrouping
inline
                                 
_PyUnicode_AsKind will not be inlined into _PyUnicode_InsertThousandsGrouping 
_PyUnicode_InsertThousandsGrouping
9351
            if (!thousands_sep_data)
9352
                return -1;
9353
        }
9354
        else {
9355
            data = _PyUnicode_AsKind(unicode, thousands_sep_kind);
inline
                   
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
_PyUnicode_InsertThousandsGrouping
inline
                   
_PyUnicode_AsKind will not be inlined into _PyUnicode_InsertThousandsGrouping 
_PyUnicode_InsertThousandsGrouping
9356
            if (!data)
9357
                return -1;
9358
        }
9359
    }
9360
9361
    switch (kind) {
9362
    case PyUnicode_1BYTE_KIND:
9363
        if (unicode != NULL && PyUnicode_IS_ASCII(unicode))
gvn
                               
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_InsertThousandsGrouping
gvn
                               
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_InsertThousandsGrouping
9364
            len = asciilib_InsertThousandsGrouping(
inline
                  
asciilib_InsertThousandsGrouping can be inlined into _PyUnicode_InsertThousandsGrouping with cost=-14465 (threshold=250) 
_PyUnicode_InsertThousandsGrouping
inline
                  
asciilib_InsertThousandsGrouping inlined into _PyUnicode_InsertThousandsGrouping 
_PyUnicode_InsertThousandsGrouping
9365
                (Py_UCS1 *) data, n_buffer, (Py_UCS1 *) digits, n_digits,
9366
                min_width, grouping,
9367
                (Py_UCS1 *) thousands_sep_data, thousands_sep_len);
9368
        else
9369
            len = ucs1lib_InsertThousandsGrouping(
inline
                  
ucs1lib_InsertThousandsGrouping can be inlined into _PyUnicode_InsertThousandsGrouping with cost=-14465 (threshold=250) 
_PyUnicode_InsertThousandsGrouping
inline
                  
ucs1lib_InsertThousandsGrouping inlined into _PyUnicode_InsertThousandsGrouping 
_PyUnicode_InsertThousandsGrouping
9370
                (Py_UCS1*)data, n_buffer, (Py_UCS1*)digits, n_digits,
9371
                min_width, grouping,
9372
                (Py_UCS1 *) thousands_sep_data, thousands_sep_len);
9373
        break;
9374
    case PyUnicode_2BYTE_KIND:
9375
        len = ucs2lib_InsertThousandsGrouping(
inline
              
ucs2lib_InsertThousandsGrouping can be inlined into _PyUnicode_InsertThousandsGrouping with cost=-14410 (threshold=250) 
_PyUnicode_InsertThousandsGrouping
inline
              
ucs2lib_InsertThousandsGrouping inlined into _PyUnicode_InsertThousandsGrouping 
_PyUnicode_InsertThousandsGrouping
9376
            (Py_UCS2 *) data, n_buffer, (Py_UCS2 *) digits, n_digits,
9377
            min_width, grouping,
9378
            (Py_UCS2 *) thousands_sep_data, thousands_sep_len);
9379
        break;
9380
    case PyUnicode_4BYTE_KIND:
9381
        len = ucs4lib_InsertThousandsGrouping(
inline
              
ucs4lib_InsertThousandsGrouping can be inlined into _PyUnicode_InsertThousandsGrouping with cost=-14410 (threshold=250) 
_PyUnicode_InsertThousandsGrouping
inline
              
ucs4lib_InsertThousandsGrouping inlined into _PyUnicode_InsertThousandsGrouping 
_PyUnicode_InsertThousandsGrouping
9382
            (Py_UCS4 *) data, n_buffer, (Py_UCS4 *) digits, n_digits,
9383
            min_width, grouping,
9384
            (Py_UCS4 *) thousands_sep_data, thousands_sep_len);
9385
        break;
9386
    default:
9387
        assert(0);
9388
        return -1;
9389
    }
9390
    if (unicode != NULL && thousands_sep_kind != kind) {
9391
        if (thousands_sep_kind < kind)
9392
            PyMem_Free(thousands_sep_data);
inline
            
PyMem_Free will not be inlined into _PyUnicode_InsertThousandsGrouping because its definition is unavailable 
_PyUnicode_InsertThousandsGrouping
9393
        else
9394
            PyMem_Free(data);
inline
            
PyMem_Free will not be inlined into _PyUnicode_InsertThousandsGrouping because its definition is unavailable 
_PyUnicode_InsertThousandsGrouping
9395
    }
9396
    if (unicode == NULL) {
9397
        *maxchar = 127;
9398
        if (len != n_digits) {
9399
            *maxchar = Py_MAX(*maxchar,
gvn
                       
load of type i32 not eliminated in favor of load because it is clobbered by store 
_PyUnicode_InsertThousandsGrouping
9400
                                   PyUnicode_MAX_CHAR_VALUE(thousands_sep));
9401
        }
9402
    }
9403
    return len;
9404
}
9405
9406
9407
Py_ssize_t
9408
PyUnicode_Count(PyObject *str,
9409
                PyObject *substr,
9410
                Py_ssize_t start,
9411
                Py_ssize_t end)
9412
{
9413
    Py_ssize_t result;
9414
    int kind1, kind2;
9415
    void *buf1 = NULL, *buf2 = NULL;
9416
    Py_ssize_t len1, len2;
9417
9418
    if (ensure_unicode(str) < 0 || ensure_unicode(substr) < 0)
inline
        
ensure_unicode can be inlined into PyUnicode_Count with cost=95 (threshold=250) 
PyUnicode_Count
inline
        
ensure_unicode inlined into PyUnicode_Count 
PyUnicode_Count
inline
                                   
ensure_unicode can be inlined into PyUnicode_Count with cost=95 (threshold=250) 
PyUnicode_Count
inline
                                   
ensure_unicode inlined into PyUnicode_Count 
PyUnicode_Count
9419
        return -1;
9420
9421
    kind1 = PyUnicode_KIND(str);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Count
9422
    kind2 = PyUnicode_KIND(substr);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Count
gvn
            
load eliminated by PRE 
PyUnicode_Count
9423
    if (kind1 < kind2)
9424
        return 0;
9425
9426
    len1 = PyUnicode_GET_LENGTH(str);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Count
9427
    len2 = PyUnicode_GET_LENGTH(substr);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Count
9428
    ADJUST_INDICES(start, end, len1);
9429
    if (end - start < len2)
9430
        return 0;
9431
9432
    buf1 = PyUnicode_DATA(str);
gvn
           
load of type i32 eliminated in favor of load 
PyUnicode_Count
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Count
9433
    buf2 = PyUnicode_DATA(substr);
gvn
           
load of type i32 eliminated in favor of phi 
PyUnicode_Count
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Count
9434
    if (kind2 != kind1) {
9435
        buf2 = _PyUnicode_AsKind(substr, kind1);
inline
               
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
PyUnicode_Count
inline
               
_PyUnicode_AsKind will not be inlined into PyUnicode_Count 
PyUnicode_Count
9436
        if (!buf2)
9437
            goto onError;
9438
    }
9439
9440
    switch (kind1) {
9441
    case PyUnicode_1BYTE_KIND:
9442
        if (PyUnicode_IS_ASCII(str) && PyUnicode_IS_ASCII(substr))
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Count
gvn
                                       
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Count
9443
            result = asciilib_count(
inline
                     
asciilib_count can be inlined into PyUnicode_Count with cost=50 (threshold=325) 
PyUnicode_Count
inline
                     
asciilib_count inlined into PyUnicode_Count 
PyUnicode_Count
9444
                ((Py_UCS1*)buf1) + start, end - start,
9445
                buf2, len2, PY_SSIZE_T_MAX
9446
                );
9447
        else
9448
            result = ucs1lib_count(
inline
                     
ucs1lib_count can be inlined into PyUnicode_Count with cost=50 (threshold=325) 
PyUnicode_Count
inline
                     
ucs1lib_count inlined into PyUnicode_Count 
PyUnicode_Count
9449
                ((Py_UCS1*)buf1) + start, end - start,
9450
                buf2, len2, PY_SSIZE_T_MAX
9451
                );
9452
        break;
9453
    case PyUnicode_2BYTE_KIND:
9454
        result = ucs2lib_count(
inline
                 
ucs2lib_count can be inlined into PyUnicode_Count with cost=50 (threshold=325) 
PyUnicode_Count
inline
                 
ucs2lib_count inlined into PyUnicode_Count 
PyUnicode_Count
9455
            ((Py_UCS2*)buf1) + start, end - start,
9456
            buf2, len2, PY_SSIZE_T_MAX
9457
            );
9458
        break;
9459
    case PyUnicode_4BYTE_KIND:
9460
        result = ucs4lib_count(
inline
                 
ucs4lib_count can be inlined into PyUnicode_Count with cost=50 (threshold=325) 
PyUnicode_Count
inline
                 
ucs4lib_count inlined into PyUnicode_Count 
PyUnicode_Count
9461
            ((Py_UCS4*)buf1) + start, end - start,
9462
            buf2, len2, PY_SSIZE_T_MAX
9463
            );
9464
        break;
9465
    default:
9466
        assert(0); result = 0;
9467
    }
9468
9469
    if (kind2 != kind1)
9470
        PyMem_Free(buf2);
inline
        
PyMem_Free will not be inlined into PyUnicode_Count because its definition is unavailable 
PyUnicode_Count
9471
9472
    return result;
9473
  onError:
9474
    if (kind2 != kind1 && buf2)
9475
        PyMem_Free(buf2);
9476
    return -1;
9477
}
9478
9479
Py_ssize_t
9480
PyUnicode_Find(PyObject *str,
9481
               PyObject *substr,
9482
               Py_ssize_t start,
9483
               Py_ssize_t end,
9484
               int direction)
9485
{
9486
    if (ensure_unicode(str) < 0 || ensure_unicode(substr) < 0)
inline
        
ensure_unicode can be inlined into PyUnicode_Find with cost=95 (threshold=250) 
PyUnicode_Find
inline
        
ensure_unicode inlined into PyUnicode_Find 
PyUnicode_Find
inline
                                   
ensure_unicode can be inlined into PyUnicode_Find with cost=95 (threshold=250) 
PyUnicode_Find
inline
                                   
ensure_unicode inlined into PyUnicode_Find 
PyUnicode_Find
9487
        return -2;
9488
9489
    return any_find_slice(str, substr, start, end, direction);
inline
           
any_find_slice too costly to inline (cost=645, threshold=625) 
PyUnicode_Find
inline
           
any_find_slice will not be inlined into PyUnicode_Find 
PyUnicode_Find
9490
}
9491
9492
Py_ssize_t
9493
PyUnicode_FindChar(PyObject *str, Py_UCS4 ch,
9494
                   Py_ssize_t start, Py_ssize_t end,
9495
                   int direction)
9496
{
9497
    int kind;
9498
    Py_ssize_t result;
9499
    if (PyUnicode_READY(str) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_FindChar
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_FindChar 
PyUnicode_FindChar
9500
        return -2;
9501
    if (start < 0 || end < 0) {
9502
        PyErr_SetString(PyExc_IndexError, "string index out of range");
inline
        
PyErr_SetString will not be inlined into PyUnicode_FindChar because its definition is unavailable 
PyUnicode_FindChar
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FindChar
9503
        return -2;
9504
    }
9505
    if (end > PyUnicode_GET_LENGTH(str))
gvn
              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FindChar
9506
        end = PyUnicode_GET_LENGTH(str);
9507
    if (start >= end)
9508
        return -1;
9509
    kind = PyUnicode_KIND(str);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_FindChar
9510
    result = findchar(PyUnicode_1BYTE_DATA(str) + kind*start,
inline
             
findchar can be inlined into PyUnicode_FindChar with cost=295 (threshold=325) 
PyUnicode_FindChar
inline
             
findchar inlined into PyUnicode_FindChar 
PyUnicode_FindChar
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FindChar
9511
                      kind, end-start, ch, direction);
9512
    if (result == -1)
9513
        return -1;
9514
    else
9515
        return start + result;
9516
}
9517
9518
static int
9519
tailmatch(PyObject *self,
9520
          PyObject *substring,
9521
          Py_ssize_t start,
9522
          Py_ssize_t end,
9523
          int direction)
9524
{
9525
    int kind_self;
9526
    int kind_sub;
9527
    void *data_self;
9528
    void *data_sub;
9529
    Py_ssize_t offset;
9530
    Py_ssize_t i;
9531
    Py_ssize_t end_sub;
9532
9533
    if (PyUnicode_READY(self) == -1 ||
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
tailmatch
inline
        
_PyUnicode_Ready will not be inlined into tailmatch 
tailmatch
9534
        PyUnicode_READY(substring) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
tailmatch
inline
        
_PyUnicode_Ready will not be inlined into tailmatch 
tailmatch
gvn
        
load of type i32 not eliminated because it is clobbered by call 
tailmatch
9535
        return -1;
9536
9537
    ADJUST_INDICES(start, end, PyUnicode_GET_LENGTH(self));
gvn
    
load of type i64 not eliminated because it is clobbered by call 
tailmatch
gvn
    
load of type i64 not eliminated because it is clobbered by call 
tailmatch
gvn
    
load of type i64 eliminated in favor of load 
tailmatch
9538
    end -= PyUnicode_GET_LENGTH(substring);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
tailmatch
gvn
           
load of type i64 not eliminated because it is clobbered by call 
tailmatch
9539
    if (end < start)
9540
        return 0;
9541
9542
    if (PyUnicode_GET_LENGTH(substring) == 0)
9543
        return 1;
9544
9545
    kind_self = PyUnicode_KIND(self);
gvn
                
load of type i32 not eliminated in favor of load because it is clobbered by call 
tailmatch
gvn
                
load of type i32 not eliminated in favor of load because it is clobbered by call 
tailmatch
9546
    data_self = PyUnicode_DATA(self);
gvn
                
load of type i8* not eliminated because it is clobbered by call 
tailmatch
gvn
                
load of type i8* not eliminated because it is clobbered by call 
tailmatch
9547
    kind_sub = PyUnicode_KIND(substring);
gvn
               
load of type i32 not eliminated in favor of load because it is clobbered by call 
tailmatch
9548
    data_sub = PyUnicode_DATA(substring);
gvn
               
load of type i8* not eliminated because it is clobbered by call 
tailmatch
gvn
               
load of type i8* not eliminated because it is clobbered by call 
tailmatch
9549
    end_sub = PyUnicode_GET_LENGTH(substring) - 1;
gvn
              
load of type i64 eliminated in favor of load 
tailmatch
9550
9551
    if (direction > 0)
9552
        offset = end;
9553
    else
9554
        offset = start;
9555
9556
    if (PyUnicode_READ(kind_self, data_self, offset) ==
9557
        PyUnicode_READ(kind_sub, data_sub, 0) &&
9558
        PyUnicode_READ(kind_self, data_self, offset + end_sub) ==
9559
        PyUnicode_READ(kind_sub, data_sub, end_sub)) {
9560
        /* If both are of the same kind, memcmp is sufficient */
9561
        if (kind_self == kind_sub) {
9562
            return ! memcmp((char *)data_self +
inline
                     
memcmp will not be inlined into tailmatch because its definition is unavailable 
tailmatch
9563
                                (offset * PyUnicode_KIND(substring)),
gvn
                                          
load of type i32 eliminated in favor of load 
tailmatch
9564
                            data_sub,
9565
                            PyUnicode_GET_LENGTH(substring) *
gvn
                            
load of type i64 eliminated in favor of load 
tailmatch
9566
                                PyUnicode_KIND(substring));
9567
        }
9568
        /* otherwise we have to compare each character by first accessing it */
9569
        else {
9570
            /* We do not need to compare 0 and len(substring)-1 because
9571
               the if statement above ensured already that they are equal
9572
               when we end up here. */
9573
            for (i = 1; i < end_sub; ++i) {
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
tailmatch
loop-vectorize
            
loop not vectorized 
tailmatch
9574
                if (PyUnicode_READ(kind_self, data_self, offset + i) !=
licm
                    
hosting icmp 
tailmatch
licm
                    
hosting bitcast 
tailmatch
9575
                    PyUnicode_READ(kind_sub, data_sub, i))
licm
                    
hosting icmp 
tailmatch
licm
                    
hosting bitcast 
tailmatch
9576
                    return 0;
9577
            }
9578
            return 1;
9579
        }
9580
    }
9581
9582
    return 0;
9583
}
9584
9585
Py_ssize_t
9586
PyUnicode_Tailmatch(PyObject *str,
9587
                    PyObject *substr,
9588
                    Py_ssize_t start,
9589
                    Py_ssize_t end,
9590
                    int direction)
9591
{
9592
    if (ensure_unicode(str) < 0 || ensure_unicode(substr) < 0)
inline
        
ensure_unicode can be inlined into PyUnicode_Tailmatch with cost=95 (threshold=250) 
PyUnicode_Tailmatch
inline
        
ensure_unicode inlined into PyUnicode_Tailmatch 
PyUnicode_Tailmatch
inline
                                   
ensure_unicode can be inlined into PyUnicode_Tailmatch with cost=95 (threshold=250) 
PyUnicode_Tailmatch
inline
                                   
ensure_unicode inlined into PyUnicode_Tailmatch 
PyUnicode_Tailmatch
9593
        return -1;
9594
9595
    return tailmatch(str, substr, start, end, direction);
inline
           
tailmatch too costly to inline (cost=630, threshold=625) 
PyUnicode_Tailmatch
inline
           
tailmatch will not be inlined into PyUnicode_Tailmatch 
PyUnicode_Tailmatch
9596
}
9597
9598
/* Apply fixfct filter to the Unicode object self and return a
9599
   reference to the modified object */
9600
9601
static PyObject *
9602
fixup(PyObject *self,
9603
      Py_UCS4 (*fixfct)(PyObject *s))
9604
{
9605
    PyObject *u;
9606
    Py_UCS4 maxchar_old, maxchar_new = 0;
9607
    PyObject *v;
9608
9609
    u = _PyUnicode_Copy(self);
inline
        
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
fixup
inline
        
_PyUnicode_Copy will not be inlined into fixup 
fixup
inline
        
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
_PyUnicode_TransformDecimalAndSpaceToASCII
inline
        
_PyUnicode_Copy will not be inlined into _PyUnicode_TransformDecimalAndSpaceToASCII 
_PyUnicode_TransformDecimalAndSpaceToASCII
9610
    if (u == NULL)
9611
        return NULL;
9612
    maxchar_old = PyUnicode_MAX_CHAR_VALUE(u);
gvn
                  
load of type i32 not eliminated because it is clobbered by call 
fixup
gvn
                  
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
9613
9614
    /* fix functions return the new maximum character in a string,
9615
       if the kind of the resulting unicode object does not change,
9616
       everything is fine.  Otherwise we need to change the string kind
9617
       and re-run the fix function. */
9618
    maxchar_new = fixfct(u);
inline
                  
fix_decimal_and_space_to_ascii too costly to inline (cost=590, threshold=250) 
fixup
inline
                  
fix_decimal_and_space_to_ascii will not be inlined into fixup 
fixup
inline
                  
fix_decimal_and_space_to_ascii too costly to inline (cost=590, threshold=250) 
_PyUnicode_TransformDecimalAndSpaceToASCII
inline
                  
fix_decimal_and_space_to_ascii will not be inlined into _PyUnicode_TransformDecimalAndSpaceToASCII 
_PyUnicode_TransformDecimalAndSpaceToASCII
9619
9620
    if (maxchar_new == 0) {
9621
        /* no changes */;
9622
        if (PyUnicode_CheckExact(self)) {
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
fixup
gvn
            
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
9623
            Py_DECREF(u);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
fixup
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
fixup
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
9624
            Py_INCREF(self);
gvn
            
load of type i64 not eliminated because it is clobbered by store 
fixup
gvn
            
load of type i64 not eliminated because it is clobbered by call 
fixup
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
gvn
            
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_TransformDecimalAndSpaceToASCII
9625
            return self;
9626
        }
9627
        else
9628
            return u;
9629
    }
9630
9631
    maxchar_new = align_maxchar(maxchar_new);
inline
                  
align_maxchar can be inlined into fixup with cost=-15005 (threshold=325) 
fixup
inline
                  
align_maxchar inlined into fixup 
fixup
9632
9633
    if (maxchar_new == maxchar_old)
9634
        return u;
9635
9636
    /* In case the maximum character changed, we need to
9637
       convert the string to the new category. */
9638
    v = PyUnicode_New(PyUnicode_GET_LENGTH(self), maxchar_new);
inline
        
PyUnicode_New too costly to inline (cost=460, threshold=250) 
fixup
inline
        
PyUnicode_New will not be inlined into fixup 
fixup
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
fixup
inline
        
PyUnicode_New too costly to inline (cost=460, threshold=250) 
_PyUnicode_TransformDecimalAndSpaceToASCII
inline
        
PyUnicode_New will not be inlined into _PyUnicode_TransformDecimalAndSpaceToASCII 
_PyUnicode_TransformDecimalAndSpaceToASCII
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
9639
    if (v == NULL) {
9640
        Py_DECREF(u);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
fixup
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
fixup
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
9641
        return NULL;
9642
    }
9643
    if (maxchar_new > maxchar_old) {
9644
        /* If the maxchar increased so that the kind changed, not all
9645
           characters are representable anymore and we need to fix the
9646
           string again. This only happens in very few cases. */
9647
        _PyUnicode_FastCopyCharacters(v, 0,
inline
        
_PyUnicode_FastCopyCharacters can be inlined into fixup with cost=5 (threshold=375) 
fixup
inline
        
_PyUnicode_FastCopyCharacters inlined into fixup 
fixup
9648
                                      self, 0, PyUnicode_GET_LENGTH(self));
gvn
                                               
load of type i64 not eliminated in favor of load because it is clobbered by call 
fixup
gvn
                                               
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
9649
        maxchar_old = fixfct(v);
inline
                      
fix_decimal_and_space_to_ascii too costly to inline (cost=590, threshold=250) 
fixup
inline
                      
fix_decimal_and_space_to_ascii will not be inlined into fixup 
fixup
inline
                      
fix_decimal_and_space_to_ascii too costly to inline (cost=590, threshold=250) 
_PyUnicode_TransformDecimalAndSpaceToASCII
inline
                      
fix_decimal_and_space_to_ascii will not be inlined into _PyUnicode_TransformDecimalAndSpaceToASCII 
_PyUnicode_TransformDecimalAndSpaceToASCII
9650
        assert(maxchar_old > 0 && maxchar_old <= maxchar_new);
9651
    }
9652
    else {
9653
        _PyUnicode_FastCopyCharacters(v, 0,
inline
        
_PyUnicode_FastCopyCharacters can be inlined into fixup with cost=5 (threshold=375) 
fixup
inline
        
_PyUnicode_FastCopyCharacters inlined into fixup 
fixup
9654
                                      u, 0, PyUnicode_GET_LENGTH(self));
9655
    }
9656
    Py_DECREF(u);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
fixup
gvn
    
load of type i64 not eliminated because it is clobbered by call 
fixup
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
fixup
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
fixup
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_TransformDecimalAndSpaceToASCII
9657
    assert(_PyUnicode_CheckConsistency(v, 1));
9658
    return v;
9659
}
9660
9661
static PyObject *
9662
ascii_upper_or_lower(PyObject *self, int lower)
9663
{
9664
    Py_ssize_t len = PyUnicode_GET_LENGTH(self);
gvn
                     
load of type i64 not eliminated because it is clobbered by call 
unicode_casefold
gvn
                     
load of type i64 not eliminated because it is clobbered by call 
unicode_lower
gvn
                     
load of type i64 not eliminated because it is clobbered by call 
unicode_upper
9665
    char *resdata, *data = PyUnicode_DATA(self);
gvn
                           
load of type i8* not eliminated because it is clobbered by call 
unicode_casefold
gvn
                           
load of type i8* not eliminated because it is clobbered by call 
unicode_lower
gvn
                           
load of type i8* not eliminated because it is clobbered by call 
unicode_upper
9666
    PyObject *res;
9667
9668
    res = PyUnicode_New(len, 127);
inline
          
PyUnicode_New too costly to inline (cost=375, threshold=250) 
ascii_upper_or_lower
inline
          
PyUnicode_New will not be inlined into ascii_upper_or_lower 
ascii_upper_or_lower
inline
          
PyUnicode_New too costly to inline (cost=375, threshold=250) 
unicode_casefold
inline
          
PyUnicode_New will not be inlined into unicode_casefold 
unicode_casefold
inline
          
PyUnicode_New too costly to inline (cost=375, threshold=250) 
unicode_lower
inline
          
PyUnicode_New will not be inlined into unicode_lower 
unicode_lower
inline
          
PyUnicode_New too costly to inline (cost=375, threshold=250) 
unicode_upper
inline
          
PyUnicode_New will not be inlined into unicode_upper 
unicode_upper
9669
    if (res == NULL)
9670
        return NULL;
9671
    resdata = PyUnicode_DATA(res);
gvn
              
load of type i32 not eliminated because it is clobbered by call 
ascii_upper_or_lower
gvn
              
load of type i8* not eliminated because it is clobbered by call 
ascii_upper_or_lower
gvn
              
load of type i32 not eliminated because it is clobbered by call 
unicode_casefold
gvn
              
load of type i8* not eliminated because it is clobbered by call 
unicode_casefold
gvn
              
load of type i32 not eliminated because it is clobbered by call 
unicode_lower
gvn
              
load of type i8* not eliminated because it is clobbered by call 
unicode_lower
gvn
              
load of type i32 not eliminated because it is clobbered by call 
unicode_upper
gvn
              
load of type i8* not eliminated because it is clobbered by call 
unicode_upper
9672
    if (lower)
9673
        _Py_bytes_lower(resdata, data, len);
inline
        
_Py_bytes_lower will not be inlined into ascii_upper_or_lower because its definition is unavailable 
ascii_upper_or_lower
9674
    else
9675
        _Py_bytes_upper(resdata, data, len);
inline
        
_Py_bytes_upper will not be inlined into ascii_upper_or_lower because its definition is unavailable 
ascii_upper_or_lower
9676
    return res;
9677
}
9678
9679
static Py_UCS4
9680
handle_capital_sigma(int kind, void *data, Py_ssize_t length, Py_ssize_t i)
9681
{
9682
    Py_ssize_t j;
9683
    int final_sigma;
9684
    Py_UCS4 c = 0;   /* initialize to prevent gcc warning */
9685
    /* U+03A3 is in the Final_Sigma context when, it is found like this:
9686
9687
     \p{cased}\p{case-ignorable}*U+03A3!(\p{case-ignorable}*\p{cased})
9688
9689
    where ! is a negation and \p{xxx} is a character with property xxx.
9690
    */
9691
    for (j = i - 1; j >= 0; j--) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
lower_ucs4
loop-vectorize
    
loop not vectorized 
lower_ucs4
9692
        c = PyUnicode_READ(kind, data, j);
licm
            
hosting bitcast 
handle_capital_sigma
9693
        if (!_PyUnicode_IsCaseIgnorable(c))
inline
             
_PyUnicode_IsCaseIgnorable will not be inlined into handle_capital_sigma because its definition is unavailable 
handle_capital_sigma
9694
            break;
9695
    }
9696
    final_sigma = j >= 0 && _PyUnicode_IsCased(c);
inline
                            
_PyUnicode_IsCased will not be inlined into handle_capital_sigma because its definition is unavailable 
handle_capital_sigma
9697
    if (final_sigma) {
9698
        for (j = i + 1; j < length; j++) {
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
lower_ucs4
loop-vectorize
        
loop not vectorized 
lower_ucs4
9699
            c = PyUnicode_READ(kind, data, j);
licm
                
hosting bitcast 
handle_capital_sigma
9700
            if (!_PyUnicode_IsCaseIgnorable(c))
inline
                 
_PyUnicode_IsCaseIgnorable will not be inlined into handle_capital_sigma because its definition is unavailable 
handle_capital_sigma
9701
                break;
9702
        }
9703
        final_sigma = j == length || !_PyUnicode_IsCased(c);
inline
                                      
_PyUnicode_IsCased will not be inlined into handle_capital_sigma because its definition is unavailable 
handle_capital_sigma
9704
    }
9705
    return (final_sigma) ? 0x3C2 : 0x3C3;
9706
}
9707
9708
static int
9709
lower_ucs4(int kind, void *data, Py_ssize_t length, Py_ssize_t i,
9710
           Py_UCS4 c, Py_UCS4 *mapped)
9711
{
9712
    /* Obscure special case. */
9713
    if (c == 0x3A3) {
9714
        mapped[0] = handle_capital_sigma(kind, data, length, i);
inline
                    
handle_capital_sigma can be inlined into lower_ucs4 with cost=-14480 (threshold=250) 
lower_ucs4
inline
                    
handle_capital_sigma inlined into lower_ucs4 
lower_ucs4
9715
        return 1;
9716
    }
9717
    return _PyUnicode_ToLowerFull(c, mapped);
inline
           
_PyUnicode_ToLowerFull will not be inlined into lower_ucs4 because its definition is unavailable 
lower_ucs4
9718
}
9719
9720
static Py_ssize_t
9721
do_capitalize(int kind, void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9722
{
9723
    Py_ssize_t i, k = 0;
9724
    int n_res, j;
9725
    Py_UCS4 c, mapped[3];
9726
9727
    c = PyUnicode_READ(kind, data, 0);
9728
    n_res = _PyUnicode_ToUpperFull(c, mapped);
inline
            
_PyUnicode_ToUpperFull will not be inlined into do_capitalize because its definition is unavailable 
do_capitalize
9729
    for (j = 0; j < n_res; j++) {
licm
                  
hosting zext 
do_capitalize
loop-vectorize
    
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop 
do_capitalize
loop-vectorize
    
loop not vectorized 
do_capitalize
loop-unroll
    
unrolled loop by a factor of 2 with run-time trip count 
do_capitalize
9730
        *maxchar = Py_MAX(*maxchar, mapped[j]);
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
do_capitalize
gvn
                   
load of type i32 not eliminated because it is clobbered by store 
do_capitalize
gvn
                   
load of type i32 not eliminated because it is clobbered by call 
do_capitalize
9731
        res[k++] = mapped[j];
9732
    }
9733
    for (i = 1; i < length; i++) {
9734
        c = PyUnicode_READ(kind, data, i);
licm
            
hosting icmp 
do_capitalize
licm
            
hosting bitcast 
do_capitalize
9735
        n_res = lower_ucs4(kind, data, length, i, c, mapped);
inline
                
lower_ucs4 too costly to inline (cost=565, threshold=250) 
do_capitalize
inline
                
lower_ucs4 will not be inlined into do_capitalize 
do_capitalize
9736
        for (j = 0; j < n_res; j++) {
licm
                      
hosting zext 
do_capitalize
loop-vectorize
        
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop 
do_capitalize
loop-vectorize
        
loop not vectorized 
do_capitalize
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
do_capitalize
9737
            *maxchar = Py_MAX(*maxchar, mapped[j]);
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
do_capitalize
gvn
                       
load of type i32 not eliminated because it is clobbered by store 
do_capitalize
gvn
                       
load of type i32 not eliminated because it is clobbered by call 
do_capitalize
licm
                       
hosting getelementptr 
do_capitalize
9738
            res[k++] = mapped[j];
9739
        }
9740
    }
9741
    return k;
9742
}
9743
9744
static Py_ssize_t
9745
do_swapcase(int kind, void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar) {
9746
    Py_ssize_t i, k = 0;
9747
9748
    for (i = 0; i < length; i++) {
9749
        Py_UCS4 c = PyUnicode_READ(kind, data, i), mapped[3];
licm
                    
hosting bitcast 
do_swapcase
licm
        
hosting bitcast 
do_swapcase
9750
        int n_res, j;
9751
        if (Py_UNICODE_ISUPPER(c)) {
inline
            
_PyUnicode_IsUppercase will not be inlined into do_swapcase because its definition is unavailable 
do_swapcase
9752
            n_res = lower_ucs4(kind, data, length, i, c, mapped);
inline
                    
lower_ucs4 too costly to inline (cost=565, threshold=250) 
do_swapcase
inline
                    
lower_ucs4 will not be inlined into do_swapcase 
do_swapcase
licm
                                                         
hosting getelementptr 
do_swapcase
9753
        }
9754
        else if (Py_UNICODE_ISLOWER(c)) {
inline
                 
_PyUnicode_IsLowercase will not be inlined into do_swapcase because its definition is unavailable 
do_swapcase
9755
            n_res = _PyUnicode_ToUpperFull(c, mapped);
inline
                    
_PyUnicode_ToUpperFull will not be inlined into do_swapcase because its definition is unavailable 
do_swapcase
9756
        }
9757
        else {
9758
            n_res = 1;
9759
            mapped[0] = c;
9760
        }
9761
        for (j = 0; j < n_res; j++) {
licm
                      
hosting zext 
do_swapcase
loop-vectorize
        
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop 
do_swapcase
loop-vectorize
        
loop not vectorized 
do_swapcase
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
do_swapcase
9762
            *maxchar = Py_MAX(*maxchar, mapped[j]);
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
do_swapcase
gvn
                       
load of type i32 not eliminated because it is clobbered by store 
do_swapcase
gvn
                       
load of type i32 not eliminated because it is clobbered by call 
do_swapcase
gvn
                       
load of type i32 not eliminated because it is clobbered by call 
do_swapcase
gvn
                       
load of type i32 not eliminated because it is clobbered by call 
do_swapcase
licm
                       
hosting getelementptr 
do_swapcase
9763
            res[k++] = mapped[j];
9764
        }
9765
    }
9766
    return k;
9767
}
9768
9769
static Py_ssize_t
9770
do_upper_or_lower(int kind, void *data, Py_ssize_t length, Py_UCS4 *res,
9771
                  Py_UCS4 *maxchar, int lower)
9772
{
9773
    Py_ssize_t i, k = 0;
9774
9775
    for (i = 0; i < length; i++) {
9776
        Py_UCS4 c = PyUnicode_READ(kind, data, i), mapped[3];
licm
                    
hosting bitcast 
do_upper_or_lower
licm
        
hosting bitcast 
do_upper_or_lower
9777
        int n_res, j;
9778
        if (lower)
licm
            
hosting icmp 
do_upper_or_lower
9779
            n_res = lower_ucs4(kind, data, length, i, c, mapped);
inline
                    
lower_ucs4 too costly to inline (cost=565, threshold=250) 
do_upper_or_lower
inline
                    
lower_ucs4 will not be inlined into do_upper_or_lower 
do_upper_or_lower
9780
        else
9781
            n_res = _PyUnicode_ToUpperFull(c, mapped);
inline
                    
_PyUnicode_ToUpperFull will not be inlined into do_upper_or_lower because its definition is unavailable 
do_upper_or_lower
9782
        for (j = 0; j < n_res; j++) {
licm
                      
hosting zext 
do_upper_or_lower
loop-vectorize
        
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop 
do_upper_or_lower
loop-vectorize
        
loop not vectorized 
do_upper_or_lower
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
do_upper_or_lower
9783
            *maxchar = Py_MAX(*maxchar, mapped[j]);
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
do_upper_or_lower
gvn
                       
load of type i32 not eliminated because it is clobbered by store 
do_upper_or_lower
gvn
                       
load of type i32 not eliminated because it is clobbered by call 
do_upper_or_lower
gvn
                       
load of type i32 not eliminated because it is clobbered by call 
do_upper_or_lower
licm
                       
hosting getelementptr 
do_upper_or_lower
9784
            res[k++] = mapped[j];
9785
        }
9786
    }
9787
    return k;
9788
}
9789
9790
static Py_ssize_t
9791
do_upper(int kind, void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9792
{
9793
    return do_upper_or_lower(kind, data, length, res, maxchar, 0);
inline
           
do_upper_or_lower too costly to inline (cost=430, threshold=250) 
do_upper
inline
           
do_upper_or_lower will not be inlined into do_upper 
do_upper
9794
}
9795
9796
static Py_ssize_t
9797
do_lower(int kind, void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9798
{
9799
    return do_upper_or_lower(kind, data, length, res, maxchar, 1);
inline
           
do_upper_or_lower too costly to inline (cost=490, threshold=250) 
do_lower
inline
           
do_upper_or_lower will not be inlined into do_lower 
do_lower
9800
}
9801
9802
static Py_ssize_t
9803
do_casefold(int kind, void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9804
{
9805
    Py_ssize_t i, k = 0;
9806
9807
    for (i = 0; i < length; i++) {
9808
        Py_UCS4 c = PyUnicode_READ(kind, data, i);
licm
                    
hosting bitcast 
do_casefold
9809
        Py_UCS4 mapped[3];
licm
        
hosting bitcast 
do_casefold
9810
        int j, n_res = _PyUnicode_ToFoldedFull(c, mapped);
inline
                       
_PyUnicode_ToFoldedFull will not be inlined into do_casefold because its definition is unavailable 
do_casefold
licm
                                                  
hosting getelementptr 
do_casefold
9811
        for (j = 0; j < n_res; j++) {
licm
                      
hosting zext 
do_casefold
loop-vectorize
        
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop 
do_casefold
loop-vectorize
        
loop not vectorized 
do_casefold
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
do_casefold
9812
            *maxchar = Py_MAX(*maxchar, mapped[j]);
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
do_casefold
gvn
                       
load of type i32 not eliminated because it is clobbered by store 
do_casefold
gvn
                       
load of type i32 not eliminated because it is clobbered by call 
do_casefold
licm
                       
hosting getelementptr 
do_casefold
9813
            res[k++] = mapped[j];
9814
        }
9815
    }
9816
    return k;
9817
}
9818
9819
static Py_ssize_t
9820
do_title(int kind, void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9821
{
9822
    Py_ssize_t i, k = 0;
9823
    int previous_is_cased;
9824
9825
    previous_is_cased = 0;
9826
    for (i = 0; i < length; i++) {
9827
        const Py_UCS4 c = PyUnicode_READ(kind, data, i);
licm
                          
hosting bitcast 
do_title
9828
        Py_UCS4 mapped[3];
licm
        
hosting bitcast 
do_title
9829
        int n_res, j;
9830
9831
        if (previous_is_cased)
9832
            n_res = lower_ucs4(kind, data, length, i, c, mapped);
inline
                    
lower_ucs4 too costly to inline (cost=565, threshold=250) 
do_title
inline
                    
lower_ucs4 will not be inlined into do_title 
do_title
9833
        else
9834
            n_res = _PyUnicode_ToTitleFull(c, mapped);
inline
                    
_PyUnicode_ToTitleFull will not be inlined into do_title because its definition is unavailable 
do_title
9835
9836
        for (j = 0; j < n_res; j++) {
licm
                      
hosting zext 
do_title
loop-vectorize
        
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop 
do_title
loop-vectorize
        
loop not vectorized 
do_title
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
do_title
9837
            *maxchar = Py_MAX(*maxchar, mapped[j]);
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
do_title
gvn
                       
load of type i32 not eliminated because it is clobbered by store 
do_title
gvn
                       
load of type i32 not eliminated because it is clobbered by call 
do_title
gvn
                       
load of type i32 not eliminated because it is clobbered by call 
do_title
licm
                       
hosting getelementptr 
do_title
9838
            res[k++] = mapped[j];
9839
        }
9840
9841
        previous_is_cased = _PyUnicode_IsCased(c);
inline
                            
_PyUnicode_IsCased will not be inlined into do_title because its definition is unavailable 
do_title
9842
    }
9843
    return k;
9844
}
9845
9846
static PyObject *
9847
case_operation(PyObject *self,
9848
               Py_ssize_t (*perform)(int, void *, Py_ssize_t, Py_UCS4 *, Py_UCS4 *))
9849
{
9850
    PyObject *res = NULL;
9851
    Py_ssize_t length, newlength = 0;
9852
    int kind, outkind;
9853
    void *data, *outdata;
9854
    Py_UCS4 maxchar = 0, *tmp, *tmpend;
9855
9856
    assert(PyUnicode_IS_READY(self));
9857
9858
    kind = PyUnicode_KIND(self);
9859
    data = PyUnicode_DATA(self);
9860
    length = PyUnicode_GET_LENGTH(self);
9861
    if ((size_t) length > PY_SSIZE_T_MAX / (3 * sizeof(Py_UCS4))) {
9862
        PyErr_SetString(PyExc_OverflowError, "string is too long");
inline
        
PyErr_SetString will not be inlined into case_operation because its definition is unavailable 
case_operation
9863
        return NULL;
9864
    }
9865
    tmp = PyMem_MALLOC(sizeof(Py_UCS4) * 3 * length);
inline
          
PyMem_Malloc will not be inlined into case_operation because its definition is unavailable 
case_operation
9866
    if (tmp == NULL)
9867
        return PyErr_NoMemory();
inline
               
PyErr_NoMemory will not be inlined into case_operation because its definition is unavailable 
case_operation
9868
    newlength = perform(kind, data, length, tmp, &maxchar);
9869
    res = PyUnicode_New(newlength, maxchar);
inline
          
PyUnicode_New too costly to inline (cost=460, threshold=250) 
case_operation
inline
          
PyUnicode_New will not be inlined into case_operation 
case_operation
gvn
                                   
load of type i32 not eliminated in favor of store because it is clobbered by call 
case_operation
9870
    if (res == NULL)
9871
        goto leave;
9872
    tmpend = tmp + newlength;
9873
    outdata = PyUnicode_DATA(res);
gvn
              
load of type i32 not eliminated because it is clobbered by call 
case_operation
gvn
              
load of type i8* not eliminated because it is clobbered by call 
case_operation
9874
    outkind = PyUnicode_KIND(res);
9875
    switch (outkind) {
9876
    case PyUnicode_1BYTE_KIND:
9877
        _PyUnicode_CONVERT_BYTES(Py_UCS4, Py_UCS1, tmp, tmpend, outdata);
gvn
        
load of type i32 not eliminated because it is clobbered by call 
case_operation
gvn
        
load of type i32 not eliminated because it is clobbered by store 
case_operation
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
case_operation
loop-vectorize
        
loop not vectorized 
case_operation
9878
        break;
9879
    case PyUnicode_2BYTE_KIND:
9880
        _PyUnicode_CONVERT_BYTES(Py_UCS4, Py_UCS2, tmp, tmpend, outdata);
gvn
        
load of type i32 not eliminated because it is clobbered by call 
case_operation
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
case_operation
loop-vectorize
        
loop not vectorized 
case_operation
9881
        break;
9882
    case PyUnicode_4BYTE_KIND:
9883
        memcpy(outdata, tmp, sizeof(Py_UCS4) * newlength);
9884
        break;
9885
    default:
9886
        assert(0);
9887
        break;
9888
    }
9889
  leave:
9890
    PyMem_FREE(tmp);
inline
    
PyMem_Free will not be inlined into case_operation because its definition is unavailable 
case_operation
9891
    return res;
9892
}
9893
9894
PyObject *
9895
PyUnicode_Join(PyObject *separator, PyObject *seq)
9896
{
9897
    PyObject *res;
9898
    PyObject *fseq;
9899
    Py_ssize_t seqlen;
9900
    PyObject **items;
9901
9902
    fseq = PySequence_Fast(seq, "can only join an iterable");
inline
           
PySequence_Fast will not be inlined into PyUnicode_Join because its definition is unavailable 
PyUnicode_Join
9903
    if (fseq == NULL) {
9904
        return NULL;
9905
    }
9906
9907
    /* NOTE: the following code can't call back into Python code,
9908
     * so we are sure that fseq won't be mutated.
9909
     */
9910
9911
    items = PySequence_Fast_ITEMS(fseq);
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Join
gvn
            
load of type %struct._object** not eliminated because it is clobbered by call 
PyUnicode_Join
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_join
gvn
            
load of type %struct._object** not eliminated because it is clobbered by call 
unicode_join
9912
    seqlen = PySequence_Fast_GET_SIZE(fseq);
9913
    res = _PyUnicode_JoinArray(separator, items, seqlen);
inline
          
_PyUnicode_JoinArray too costly to inline (cost=650, threshold=625) 
PyUnicode_Join
inline
          
_PyUnicode_JoinArray will not be inlined into PyUnicode_Join 
PyUnicode_Join
inline
          
_PyUnicode_JoinArray too costly to inline (cost=650, threshold=625) 
unicode_join
inline
          
_PyUnicode_JoinArray will not be inlined into unicode_join 
unicode_join
9914
    Py_DECREF(fseq);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Join
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Join
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_join
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_join
9915
    return res;
9916
}
9917
9918
PyObject *
9919
_PyUnicode_JoinArray(PyObject *separator, PyObject **items, Py_ssize_t seqlen)
9920
{
9921
    PyObject *res = NULL; /* the result */
9922
    PyObject *sep = NULL;
9923
    Py_ssize_t seplen;
9924
    PyObject *item;
9925
    Py_ssize_t sz, i, res_offset;
9926
    Py_UCS4 maxchar;
9927
    Py_UCS4 item_maxchar;
9928
    int use_memcpy;
9929
    unsigned char *res_data = NULL, *sep_data = NULL;
9930
    PyObject *last_obj;
9931
    unsigned int kind = 0;
9932
9933
    /* If empty sequence, return u"". */
9934
    if (seqlen == 0) {
9935
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
_PyUnicode_JoinArray
inline
        
PyUnicode_New will not be inlined into _PyUnicode_JoinArray 
_PyUnicode_JoinArray
gvn
        
load of type %struct._object* eliminated in favor of phi 
_PyUnicode_JoinArray
9936
    }
9937
9938
    /* If singleton sequence with an exact Unicode, return that. */
9939
    last_obj = NULL;
9940
    if (seqlen == 1) {
9941
        if (PyUnicode_CheckExact(items[0])) {
9942
            res = items[0];
9943
            Py_INCREF(res);
9944
            return res;
9945
        }
9946
        seplen = 0;
9947
        maxchar = 0;
9948
    }
9949
    else {
9950
        /* Set up sep and seplen */
9951
        if (separator == NULL) {
9952
            /* fall back to a blank space separator */
9953
            sep = PyUnicode_FromOrdinal(' ');
inline
                  
PyUnicode_FromOrdinal can be inlined into _PyUnicode_JoinArray with cost=95 (threshold=250) 
_PyUnicode_JoinArray
inline
                  
PyUnicode_FromOrdinal inlined into _PyUnicode_JoinArray 
_PyUnicode_JoinArray
9954
            if (!sep)
9955
                goto onError;
9956
            seplen = 1;
9957
            maxchar = 32;
9958
        }
9959
        else {
9960
            if (!PyUnicode_Check(separator)) {
9961
                PyErr_Format(PyExc_TypeError,
inline
                
PyErr_Format will not be inlined into _PyUnicode_JoinArray because its definition is unavailable 
_PyUnicode_JoinArray
9962
                             "separator: expected str instance,"
9963
                             " %.80s found",
9964
                             Py_TYPE(separator)->tp_name);
9965
                goto onError;
9966
            }
9967
            if (PyUnicode_READY(separator))
inline
                
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_JoinArray
inline
                
_PyUnicode_Ready will not be inlined into _PyUnicode_JoinArray 
_PyUnicode_JoinArray
9968
                goto onError;
9969
            sep = separator;
9970
            seplen = PyUnicode_GET_LENGTH(separator);
gvn
                     
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
9971
            maxchar = PyUnicode_MAX_CHAR_VALUE(separator);
gvn
                      
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_JoinArray
gvn
                      
load eliminated by PRE 
_PyUnicode_JoinArray
9972
            /* inc refcount to keep this code path symmetric with the
9973
               above case of a blank separator */
9974
            Py_INCREF(sep);
9975
        }
9976
        last_obj = sep;
9977
    }
9978
9979
    /* There are at least two things to join, or else we have a subclass
9980
     * of str in the sequence.
9981
     * Do a pre-pass to figure out the total amount of space we'll
9982
     * need (sz), and see whether all argument are strings.
9983
     */
9984
    sz = 0;
9985
#ifdef Py_DEBUG
9986
    use_memcpy = 0;
9987
#else
9988
    use_memcpy = 1;
9989
#endif
9990
    for (i = 0; i < seqlen; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_JoinArray
loop-vectorize
    
loop not vectorized 
_PyUnicode_JoinArray
9991
        const Py_ssize_t old_sz = sz;
9992
        item = items[i];
gvn
               
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
               
load of type %struct._object* not eliminated because it is clobbered by store 
_PyUnicode_JoinArray
9993
        if (!PyUnicode_Check(item)) {
9994
            PyErr_Format(PyExc_TypeError,
inline
            
PyErr_Format will not be inlined into _PyUnicode_JoinArray because its definition is unavailable 
_PyUnicode_JoinArray
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by store 
_PyUnicode_JoinArray
9995
                         "sequence item %zd: expected str instance,"
9996
                         " %.80s found",
9997
                         i, Py_TYPE(item)->tp_name);
9998
            goto onError;
9999
        }
10000
        if (PyUnicode_READY(item) == -1)
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_JoinArray
inline
            
_PyUnicode_Ready will not be inlined into _PyUnicode_JoinArray 
_PyUnicode_JoinArray
10001
            goto onError;
10002
        sz += PyUnicode_GET_LENGTH(item);
gvn
              
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
10003
        item_maxchar = PyUnicode_MAX_CHAR_VALUE(item);
gvn
                       
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_JoinArray
gvn
                       
load eliminated by PRE 
_PyUnicode_JoinArray
10004
        maxchar = Py_MAX(maxchar, item_maxchar);
10005
        if (i != 0)
10006
            sz += seplen;
10007
        if (sz < old_sz || sz > PY_SSIZE_T_MAX) {
10008
            PyErr_SetString(PyExc_OverflowError,
inline
            
PyErr_SetString will not be inlined into _PyUnicode_JoinArray because its definition is unavailable 
_PyUnicode_JoinArray
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
_PyUnicode_JoinArray
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
10009
                            "join() result is too long for a Python string");
10010
            goto onError;
10011
        }
10012
        if (use_memcpy && last_obj != NULL) {
10013
            if (PyUnicode_KIND(last_obj) != PyUnicode_KIND(item))
gvn
                
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
                                            
load of type i32 eliminated in favor of phi 
_PyUnicode_JoinArray
10014
                use_memcpy = 0;
10015
        }
10016
        last_obj = item;
10017
    }
10018
10019
    res = PyUnicode_New(sz, maxchar);
inline
          
PyUnicode_New too costly to inline (cost=460, threshold=250) 
_PyUnicode_JoinArray
inline
          
PyUnicode_New will not be inlined into _PyUnicode_JoinArray 
_PyUnicode_JoinArray
10020
    if (res == NULL)
10021
        goto onError;
10022
10023
    /* Catenate everything. */
10024
#ifdef Py_DEBUG
10025
    use_memcpy = 0;
10026
#else
10027
    if (use_memcpy) {
10028
        res_data = PyUnicode_1BYTE_DATA(res);
gvn
                   
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
                   
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
10029
        kind = PyUnicode_KIND(res);
10030
        if (seplen != 0)
10031
            sep_data = PyUnicode_1BYTE_DATA(sep);
gvn
                       
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
                       
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
10032
    }
10033
#endif
10034
    if (use_memcpy) {
10035
        for (i = 0; i < seqlen; ++i) {
loop-vectorize
        
loop not vectorized 
_PyUnicode_JoinArray
10036
            Py_ssize_t itemlen;
10037
            item = items[i];
gvn
                   
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
10038
10039
            /* Copy item, and maybe the separator. */
10040
            if (i && seplen != 0) {
licm
                            
hosting icmp 
_PyUnicode_JoinArray
10041
                memcpy(res_data,
10042
                          sep_data,
10043
                          kind * seplen);
licm
                          
hosting zext 
_PyUnicode_JoinArray
licm
                               
hosting mul 
_PyUnicode_JoinArray
10044
                res_data += kind * seplen;
10045
            }
loop-vectorize
            
loop not vectorized: control flow cannot be substituted for a select 
_PyUnicode_JoinArray
10046
10047
            itemlen = PyUnicode_GET_LENGTH(item);
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
10048
            if (itemlen != 0) {
10049
                memcpy(res_data,
10050
                          PyUnicode_DATA(item),
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
loop-vectorize
                          
loop not vectorized: control flow cannot be substituted for a select 
_PyUnicode_JoinArray
10051
                          kind * itemlen);
licm
                          
hosting zext 
_PyUnicode_JoinArray
10052
                res_data += kind * itemlen;
10053
            }
10054
        }
10055
        assert(res_data == PyUnicode_1BYTE_DATA(res)
10056
                           + kind * PyUnicode_GET_LENGTH(res));
10057
    }
10058
    else {
10059
        for (i = 0, res_offset = 0; i < seqlen; ++i) {
loop-vectorize
        
loop not vectorized 
_PyUnicode_JoinArray
10060
            Py_ssize_t itemlen;
10061
            item = items[i];
gvn
                   
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
10062
10063
            /* Copy item, and maybe the separator. */
10064
            if (i && seplen != 0) {
licm
                            
hosting icmp 
_PyUnicode_JoinArray
10065
                _PyUnicode_FastCopyCharacters(res, res_offset, sep, 0, seplen);
inline
                
_PyUnicode_FastCopyCharacters can be inlined into _PyUnicode_JoinArray with cost=5 (threshold=375) 
_PyUnicode_JoinArray
inline
                
_PyUnicode_FastCopyCharacters inlined into _PyUnicode_JoinArray 
_PyUnicode_JoinArray
10066
                res_offset += seplen;
10067
            }
loop-vectorize
            
loop not vectorized: control flow cannot be substituted for a select 
_PyUnicode_JoinArray
10068
10069
            itemlen = PyUnicode_GET_LENGTH(item);
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
10070
            if (itemlen != 0) {
10071
                _PyUnicode_FastCopyCharacters(res, res_offset, item, 0, itemlen);
inline
                
_PyUnicode_FastCopyCharacters can be inlined into _PyUnicode_JoinArray with cost=5 (threshold=375) 
_PyUnicode_JoinArray
inline
                
_PyUnicode_FastCopyCharacters inlined into _PyUnicode_JoinArray 
_PyUnicode_JoinArray
10072
                res_offset += itemlen;
10073
            }
loop-vectorize
            
loop not vectorized: control flow cannot be substituted for a select 
_PyUnicode_JoinArray
10074
        }
10075
        assert(res_offset == PyUnicode_GET_LENGTH(res));
10076
    }
10077
10078
    Py_XDECREF(sep);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
10079
    assert(_PyUnicode_CheckConsistency(res, 1));
10080
    return res;
10081
10082
  onError:
10083
    Py_XDECREF(sep);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_JoinArray
10084
    Py_XDECREF(res);
10085
    return NULL;
10086
}
10087
10088
#define FILL(kind, data, value, start, length) \
10089
    do { \
10090
        Py_ssize_t i_ = 0; \
10091
        assert(kind != PyUnicode_WCHAR_KIND); \
10092
        switch ((kind)) { \
10093
        case PyUnicode_1BYTE_KIND: { \
10094
            unsigned char * to_ = (unsigned char *)((data)) + (start); \
10095
            memset(to_, (unsigned char)value, (length)); \
10096
            break; \
10097
        } \
10098
        case PyUnicode_2BYTE_KIND: { \
10099
            Py_UCS2 * to_ = (Py_UCS2 *)((data)) + (start); \
10100
            for (; i_ < (length); ++i_, ++to_) *to_ = (value); \
10101
            break; \
10102
        } \
10103
        case PyUnicode_4BYTE_KIND: { \
10104
            Py_UCS4 * to_ = (Py_UCS4 *)((data)) + (start); \
10105
            for (; i_ < (length); ++i_, ++to_) *to_ = (value); \
10106
            break; \
10107
        } \
10108
        default: assert(0); \
10109
        } \
10110
    } while (0)
10111
10112
void
10113
_PyUnicode_FastFill(PyObject *unicode, Py_ssize_t start, Py_ssize_t length,
10114
                    Py_UCS4 fill_char)
10115
{
10116
    const enum PyUnicode_Kind kind = PyUnicode_KIND(unicode);
gvn
                                     
load of type i32 eliminated in favor of load 
PyUnicode_Fill
10117
    const void *data = PyUnicode_DATA(unicode);
gvn
                       
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Fill
10118
    assert(PyUnicode_IS_READY(unicode));
10119
    assert(unicode_modifiable(unicode));
10120
    assert(fill_char <= PyUnicode_MAX_CHAR_VALUE(unicode));
10121
    assert(start >= 0);
10122
    assert(start + length <= PyUnicode_GET_LENGTH(unicode));
10123
    FILL(kind, data, fill_char, start, length);
licm
    
hosting trunc 
_PyUnicode_FastFill
loop-vectorize
    
vectorized loop (vectorization width: 4, interleaved count: 2) 
_PyUnicode_FastFill
loop-vectorize
    
vectorized loop (vectorization width: 8, interleaved count: 2) 
_PyUnicode_FastFill
loop-unroll
    
unrolled loop by a factor of 8 with run-time trip count 
_PyUnicode_FastFill
loop-vectorize
    
vectorized loop (vectorization width: 4, interleaved count: 2) 
PyUnicode_Fill
loop-vectorize
    
vectorized loop (vectorization width: 8, interleaved count: 2) 
PyUnicode_Fill
loop-unroll
    
unrolled loop by a factor of 8 with run-time trip count 
PyUnicode_Fill
10124
}
10125
10126
Py_ssize_t
10127
PyUnicode_Fill(PyObject *unicode, Py_ssize_t start, Py_ssize_t length,
10128
               Py_UCS4 fill_char)
10129
{
10130
    Py_ssize_t maxlen;
10131
10132
    if (!PyUnicode_Check(unicode)) {
10133
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into PyUnicode_Fill because its definition is unavailable 
PyUnicode_Fill
10134
        return -1;
10135
    }
10136
    if (PyUnicode_READY(unicode) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Fill
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_Fill 
PyUnicode_Fill
10137
        return -1;
10138
    if (unicode_check_modifiable(unicode))
inline
        
unicode_check_modifiable can be inlined into PyUnicode_Fill with cost=75 (threshold=250) 
PyUnicode_Fill
inline
        
unicode_check_modifiable inlined into PyUnicode_Fill 
PyUnicode_Fill
10139
        return -1;
10140
10141
    if (start < 0) {
10142
        PyErr_SetString(PyExc_IndexError, "string index out of range");
inline
        
PyErr_SetString will not be inlined into PyUnicode_Fill because its definition is unavailable 
PyUnicode_Fill
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Fill
10143
        return -1;
10144
    }
10145
    if (fill_char > PyUnicode_MAX_CHAR_VALUE(unicode)) {
gvn
                    
load of type i32 eliminated in favor of load 
PyUnicode_Fill
10146
        PyErr_SetString(PyExc_ValueError,
inline
        
PyErr_SetString will not be inlined into PyUnicode_Fill because its definition is unavailable 
PyUnicode_Fill
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Fill
10147
                         "fill character is bigger than "
10148
                         "the string maximum character");
10149
        return -1;
10150
    }
10151
10152
    maxlen = PyUnicode_GET_LENGTH(unicode) - start;
gvn
             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Fill
10153
    length = Py_MIN(maxlen, length);
10154
    if (length <= 0)
10155
        return 0;
10156
10157
    _PyUnicode_FastFill(unicode, start, length, fill_char);
inline
    
_PyUnicode_FastFill can be inlined into PyUnicode_Fill with cost=95 (threshold=250) 
PyUnicode_Fill
inline
    
_PyUnicode_FastFill inlined into PyUnicode_Fill 
PyUnicode_Fill
10158
    return length;
10159
}
10160
10161
static PyObject *
10162
pad(PyObject *self,
10163
    Py_ssize_t left,
10164
    Py_ssize_t right,
10165
    Py_UCS4 fill)
10166
{
10167
    PyObject *u;
10168
    Py_UCS4 maxchar;
10169
    int kind;
10170
    void *data;
10171
10172
    if (left < 0)
10173
        left = 0;
10174
    if (right < 0)
10175
        right = 0;
10176
10177
    if (left == 0 && right == 0)
10178
        return unicode_result_unchanged(self);
inline
               
unicode_result_unchanged can be inlined into pad with cost=90 (threshold=250) 
pad
inline
               
unicode_result_unchanged inlined into pad 
pad
10179
10180
    if (left > PY_SSIZE_T_MAX - _PyUnicode_LENGTH(self) ||
10181
        right > PY_SSIZE_T_MAX - (left + _PyUnicode_LENGTH(self))) {
10182
        PyErr_SetString(PyExc_OverflowError, "padded string is too long");
inline
        
PyErr_SetString will not be inlined into pad because its definition is unavailable 
pad
10183
        return NULL;
10184
    }
10185
    maxchar = PyUnicode_MAX_CHAR_VALUE(self);
10186
    maxchar = Py_MAX(maxchar, fill);
10187
    u = PyUnicode_New(left + _PyUnicode_LENGTH(self) + right, maxchar);
inline
        
PyUnicode_New too costly to inline (cost=460, threshold=250) 
pad
inline
        
PyUnicode_New will not be inlined into pad 
pad
gvn
                             
load of type i64 eliminated in favor of load 
pad
10188
    if (!u)
10189
        return NULL;
10190
10191
    kind = PyUnicode_KIND(u);
gvn
           
load of type i32 not eliminated because it is clobbered by call 
pad
10192
    data = PyUnicode_DATA(u);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
pad
10193
    if (left)
10194
        FILL(kind, data, fill, 0, left);
licm
        
hosting trunc 
pad
loop-vectorize
        
vectorized loop (vectorization width: 4, interleaved count: 2) 
pad
loop-vectorize
        
vectorized loop (vectorization width: 8, interleaved count: 2) 
pad
loop-unroll
        
unrolled loop by a factor of 8 with run-time trip count 
pad
10195
    if (right)
10196
        FILL(kind, data, fill, left + _PyUnicode_LENGTH(self), right);
licm
        
hosting trunc 
pad
gvn
        
load of type i64 not eliminated in favor of load because it is clobbered by call 
pad
gvn
        
load of type i64 not eliminated in favor of load because it is clobbered by call 
pad
loop-vectorize
        
vectorized loop (vectorization width: 4, interleaved count: 2) 
pad
loop-vectorize
        
vectorized loop (vectorization width: 8, interleaved count: 2) 
pad
loop-unroll
        
unrolled loop by a factor of 8 with run-time trip count 
pad
10197
    _PyUnicode_FastCopyCharacters(u, left, self, 0, _PyUnicode_LENGTH(self));
inline
    
_PyUnicode_FastCopyCharacters can be inlined into pad with cost=5 (threshold=375) 
pad
inline
    
_PyUnicode_FastCopyCharacters inlined into pad 
pad
gvn
                                                    
load of type i64 not eliminated in favor of load because it is clobbered by call 
pad
gvn
                                                    
load of type i64 not eliminated in favor of load because it is clobbered by call 
pad
gvn
                                                    
load of type i64 not eliminated in favor of load because it is clobbered by call 
pad
10198
    assert(_PyUnicode_CheckConsistency(u, 1));
10199
    return u;
10200
}
10201
10202
PyObject *
10203
PyUnicode_Splitlines(PyObject *string, int keepends)
10204
{
10205
    PyObject *list;
10206
10207
    if (ensure_unicode(string) < 0)
inline
        
ensure_unicode can be inlined into PyUnicode_Splitlines with cost=95 (threshold=250) 
PyUnicode_Splitlines
inline
        
ensure_unicode inlined into PyUnicode_Splitlines 
PyUnicode_Splitlines
10208
        return NULL;
10209
10210
    switch (PyUnicode_KIND(string)) {
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Splitlines
gvn
            
load eliminated by PRE 
PyUnicode_Splitlines
10211
    case PyUnicode_1BYTE_KIND:
10212
        if (PyUnicode_IS_ASCII(string))
10213
            list = asciilib_splitlines(
inline
                   
asciilib_splitlines can be inlined into PyUnicode_Splitlines with cost=-14250 (threshold=325) 
PyUnicode_Splitlines
inline
                   
asciilib_splitlines inlined into PyUnicode_Splitlines 
PyUnicode_Splitlines
10214
                string, PyUnicode_1BYTE_DATA(string),
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Splitlines
10215
                PyUnicode_GET_LENGTH(string), keepends);
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Splitlines
10216
        else
10217
            list = ucs1lib_splitlines(
inline
                   
ucs1lib_splitlines can be inlined into PyUnicode_Splitlines with cost=-14045 (threshold=325) 
PyUnicode_Splitlines
inline
                   
ucs1lib_splitlines inlined into PyUnicode_Splitlines 
PyUnicode_Splitlines
10218
                string, PyUnicode_1BYTE_DATA(string),
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Splitlines
10219
                PyUnicode_GET_LENGTH(string), keepends);
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Splitlines
10220
        break;
10221
    case PyUnicode_2BYTE_KIND:
10222
        list = ucs2lib_splitlines(
inline
               
ucs2lib_splitlines can be inlined into PyUnicode_Splitlines with cost=-14045 (threshold=325) 
PyUnicode_Splitlines
inline
               
ucs2lib_splitlines inlined into PyUnicode_Splitlines 
PyUnicode_Splitlines
10223
            string, PyUnicode_2BYTE_DATA(string),
gvn
                    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Splitlines
10224
            PyUnicode_GET_LENGTH(string), keepends);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Splitlines
10225
        break;
10226
    case PyUnicode_4BYTE_KIND:
10227
        list = ucs4lib_splitlines(
inline
               
ucs4lib_splitlines can be inlined into PyUnicode_Splitlines with cost=-14065 (threshold=325) 
PyUnicode_Splitlines
inline
               
ucs4lib_splitlines inlined into PyUnicode_Splitlines 
PyUnicode_Splitlines
10228
            string, PyUnicode_4BYTE_DATA(string),
gvn
                    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Splitlines
10229
            PyUnicode_GET_LENGTH(string), keepends);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Splitlines
10230
        break;
10231
    default:
10232
        assert(0);
10233
        list = 0;
10234
    }
10235
    return list;
10236
}
10237
10238
static PyObject *
10239
split(PyObject *self,
10240
      PyObject *substring,
10241
      Py_ssize_t maxcount)
10242
{
10243
    int kind1, kind2;
10244
    void *buf1, *buf2;
10245
    Py_ssize_t len1, len2;
10246
    PyObject* out;
10247
10248
    if (maxcount < 0)
10249
        maxcount = PY_SSIZE_T_MAX;
10250
10251
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
split
inline
        
_PyUnicode_Ready will not be inlined into split 
split
10252
        return NULL;
10253
10254
    if (substring == NULL)
10255
        switch (PyUnicode_KIND(self)) {
gvn
                
load of type i32 not eliminated in favor of load because it is clobbered by call 
split
10256
        case PyUnicode_1BYTE_KIND:
10257
            if (PyUnicode_IS_ASCII(self))
10258
                return asciilib_split_whitespace(
inline
                       
asciilib_split_whitespace can be inlined into split with cost=-13665 (threshold=325) 
split
inline
                       
asciilib_split_whitespace inlined into split 
split
10259
                    self,  PyUnicode_1BYTE_DATA(self),
gvn
                           
load of type i8* not eliminated because it is clobbered by call 
split
10260
                    PyUnicode_GET_LENGTH(self), maxcount
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
split
10261
                    );
10262
            else
10263
                return ucs1lib_split_whitespace(
inline
                       
ucs1lib_split_whitespace can be inlined into split with cost=-14075 (threshold=325) 
split
inline
                       
ucs1lib_split_whitespace inlined into split 
split
10264
                    self,  PyUnicode_1BYTE_DATA(self),
gvn
                           
load of type i8* not eliminated because it is clobbered by call 
split
10265
                    PyUnicode_GET_LENGTH(self), maxcount
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
split
10266
                    );
10267
        case PyUnicode_2BYTE_KIND:
10268
            return ucs2lib_split_whitespace(
inline
                   
ucs2lib_split_whitespace can be inlined into split with cost=-14075 (threshold=325) 
split
inline
                   
ucs2lib_split_whitespace inlined into split 
split
10269
                self,  PyUnicode_2BYTE_DATA(self),
gvn
                       
load of type i8* not eliminated because it is clobbered by call 
split
10270
                PyUnicode_GET_LENGTH(self), maxcount
gvn
                
load of type i64 not eliminated because it is clobbered by call 
split
10271
                );
10272
        case PyUnicode_4BYTE_KIND:
10273
            return ucs4lib_split_whitespace(
inline
                   
ucs4lib_split_whitespace can be inlined into split with cost=-14105 (threshold=325) 
split
inline
                   
ucs4lib_split_whitespace inlined into split 
split
10274
                self,  PyUnicode_4BYTE_DATA(self),
gvn
                       
load of type i8* not eliminated because it is clobbered by call 
split
10275
                PyUnicode_GET_LENGTH(self), maxcount
gvn
                
load of type i64 not eliminated because it is clobbered by call 
split
10276
                );
10277
        default:
10278
            assert(0);
10279
            return NULL;
10280
        }
10281
10282
    if (PyUnicode_READY(substring) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
split
inline
        
_PyUnicode_Ready will not be inlined into split 
split
gvn
        
load of type i32 not eliminated because it is clobbered by call 
split
10283
        return NULL;
10284
10285
    kind1 = PyUnicode_KIND(self);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
split
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
split
10286
    kind2 = PyUnicode_KIND(substring);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
split
gvn
            
load eliminated by PRE 
split
10287
    len1 = PyUnicode_GET_LENGTH(self);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
split
gvn
           
load of type i64 not eliminated because it is clobbered by call 
split
10288
    len2 = PyUnicode_GET_LENGTH(substring);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
split
gvn
           
load of type i64 not eliminated because it is clobbered by call 
split
10289
    if (kind1 < kind2 || len1 < len2) {
10290
        out = PyList_New(1);
inline
              
PyList_New will not be inlined into split because its definition is unavailable 
split
10291
        if (out == NULL)
10292
            return NULL;
10293
        Py_INCREF(self);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
split
10294
        PyList_SET_ITEM(out, 0, self);
gvn
        
load of type %struct._object** not eliminated because it is clobbered by call 
split
10295
        return out;
10296
    }
10297
    buf1 = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
split
gvn
           
load of type i8* not eliminated because it is clobbered by call 
split
10298
    buf2 = PyUnicode_DATA(substring);
gvn
           
load of type i32 eliminated in favor of phi 
split
gvn
           
load of type i8* not eliminated because it is clobbered by call 
split
gvn
           
load of type i8* not eliminated because it is clobbered by call 
split
10299
    if (kind2 != kind1) {
10300
        buf2 = _PyUnicode_AsKind(substring, kind1);
inline
               
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
split
inline
               
_PyUnicode_AsKind will not be inlined into split 
split
10301
        if (!buf2)
10302
            return NULL;
10303
    }
10304
10305
    switch (kind1) {
10306
    case PyUnicode_1BYTE_KIND:
10307
        if (PyUnicode_IS_ASCII(self) && PyUnicode_IS_ASCII(substring))
gvn
            
load of type i32 not eliminated because it is clobbered by call 
split
gvn
                                        
load of type i32 not eliminated in favor of load because it is clobbered by call 
split
10308
            out = asciilib_split(
inline
                  
asciilib_split can be inlined into split with cost=-12805 (threshold=325) 
split
inline
                  
asciilib_split inlined into split 
split
10309
                self,  buf1, len1, buf2, len2, maxcount);
10310
        else
10311
            out = ucs1lib_split(
inline
                  
ucs1lib_split can be inlined into split with cost=-13625 (threshold=325) 
split
inline
                  
ucs1lib_split inlined into split 
split
10312
                self,  buf1, len1, buf2, len2, maxcount);
10313
        break;
10314
    case PyUnicode_2BYTE_KIND:
10315
        out = ucs2lib_split(
inline
              
ucs2lib_split can be inlined into split with cost=-13625 (threshold=325) 
split
inline
              
ucs2lib_split inlined into split 
split
10316
            self,  buf1, len1, buf2, len2, maxcount);
10317
        break;
10318
    case PyUnicode_4BYTE_KIND:
10319
        out = ucs4lib_split(
inline
              
ucs4lib_split can be inlined into split with cost=-13625 (threshold=325) 
split
inline
              
ucs4lib_split inlined into split 
split
10320
            self,  buf1, len1, buf2, len2, maxcount);
10321
        break;
10322
    default:
10323
        out = NULL;
10324
    }
10325
    if (kind2 != kind1)
10326
        PyMem_Free(buf2);
inline
        
PyMem_Free will not be inlined into split because its definition is unavailable 
split
10327
    return out;
10328
}
10329
10330
static PyObject *
10331
rsplit(PyObject *self,
10332
       PyObject *substring,
10333
       Py_ssize_t maxcount)
10334
{
10335
    int kind1, kind2;
10336
    void *buf1, *buf2;
10337
    Py_ssize_t len1, len2;
10338
    PyObject* out;
10339
10340
    if (maxcount < 0)
10341
        maxcount = PY_SSIZE_T_MAX;
10342
10343
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
rsplit
inline
        
_PyUnicode_Ready will not be inlined into rsplit 
rsplit
10344
        return NULL;
10345
10346
    if (substring == NULL)
10347
        switch (PyUnicode_KIND(self)) {
gvn
                
load of type i32 not eliminated in favor of load because it is clobbered by call 
rsplit
10348
        case PyUnicode_1BYTE_KIND:
10349
            if (PyUnicode_IS_ASCII(self))
10350
                return asciilib_rsplit_whitespace(
inline
                       
asciilib_rsplit_whitespace can be inlined into rsplit with cost=-13645 (threshold=325) 
rsplit
inline
                       
asciilib_rsplit_whitespace inlined into rsplit 
rsplit
10351
                    self,  PyUnicode_1BYTE_DATA(self),
gvn
                           
load of type i8* not eliminated because it is clobbered by call 
rsplit
10352
                    PyUnicode_GET_LENGTH(self), maxcount
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
rsplit
10353
                    );
10354
            else
10355
                return ucs1lib_rsplit_whitespace(
inline
                       
ucs1lib_rsplit_whitespace can be inlined into rsplit with cost=-14055 (threshold=325) 
rsplit
inline
                       
ucs1lib_rsplit_whitespace inlined into rsplit 
rsplit
10356
                    self,  PyUnicode_1BYTE_DATA(self),
gvn
                           
load of type i8* not eliminated because it is clobbered by call 
rsplit
10357
                    PyUnicode_GET_LENGTH(self), maxcount
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
rsplit
10358
                    );
10359
        case PyUnicode_2BYTE_KIND:
10360
            return ucs2lib_rsplit_whitespace(
inline
                   
ucs2lib_rsplit_whitespace can be inlined into rsplit with cost=-14055 (threshold=325) 
rsplit
inline
                   
ucs2lib_rsplit_whitespace inlined into rsplit 
rsplit
10361
                self,  PyUnicode_2BYTE_DATA(self),
gvn
                       
load of type i8* not eliminated because it is clobbered by call 
rsplit
10362
                PyUnicode_GET_LENGTH(self), maxcount
gvn
                
load of type i64 not eliminated because it is clobbered by call 
rsplit
10363
                );
10364
        case PyUnicode_4BYTE_KIND:
10365
            return ucs4lib_rsplit_whitespace(
inline
                   
ucs4lib_rsplit_whitespace can be inlined into rsplit with cost=-14085 (threshold=325) 
rsplit
inline
                   
ucs4lib_rsplit_whitespace inlined into rsplit 
rsplit
10366
                self,  PyUnicode_4BYTE_DATA(self),
gvn
                       
load of type i8* not eliminated because it is clobbered by call 
rsplit
10367
                PyUnicode_GET_LENGTH(self), maxcount
gvn
                
load of type i64 not eliminated because it is clobbered by call 
rsplit
10368
                );
10369
        default:
10370
            assert(0);
10371
            return NULL;
10372
        }
10373
10374
    if (PyUnicode_READY(substring) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
rsplit
inline
        
_PyUnicode_Ready will not be inlined into rsplit 
rsplit
gvn
        
load of type i32 not eliminated because it is clobbered by call 
rsplit
10375
        return NULL;
10376
10377
    kind1 = PyUnicode_KIND(self);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
rsplit
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
rsplit
10378
    kind2 = PyUnicode_KIND(substring);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
rsplit
gvn
            
load eliminated by PRE 
rsplit
10379
    len1 = PyUnicode_GET_LENGTH(self);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
rsplit
gvn
           
load of type i64 not eliminated because it is clobbered by call 
rsplit
10380
    len2 = PyUnicode_GET_LENGTH(substring);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
rsplit
gvn
           
load of type i64 not eliminated because it is clobbered by call 
rsplit
10381
    if (kind1 < kind2 || len1 < len2) {
10382
        out = PyList_New(1);
inline
              
PyList_New will not be inlined into rsplit because its definition is unavailable 
rsplit
10383
        if (out == NULL)
10384
            return NULL;
10385
        Py_INCREF(self);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
rsplit
10386
        PyList_SET_ITEM(out, 0, self);
gvn
        
load of type %struct._object** not eliminated because it is clobbered by call 
rsplit
10387
        return out;
10388
    }
10389
    buf1 = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
rsplit
gvn
           
load of type i8* not eliminated because it is clobbered by call 
rsplit
10390
    buf2 = PyUnicode_DATA(substring);
gvn
           
load of type i32 eliminated in favor of phi 
rsplit
gvn
           
load of type i8* not eliminated because it is clobbered by call 
rsplit
gvn
           
load of type i8* not eliminated because it is clobbered by call 
rsplit
10391
    if (kind2 != kind1) {
10392
        buf2 = _PyUnicode_AsKind(substring, kind1);
inline
               
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
rsplit
inline
               
_PyUnicode_AsKind will not be inlined into rsplit 
rsplit
10393
        if (!buf2)
10394
            return NULL;
10395
    }
10396
10397
    switch (kind1) {
10398
    case PyUnicode_1BYTE_KIND:
10399
        if (PyUnicode_IS_ASCII(self) && PyUnicode_IS_ASCII(substring))
gvn
            
load of type i32 not eliminated because it is clobbered by call 
rsplit
gvn
                                        
load of type i32 not eliminated in favor of load because it is clobbered by call 
rsplit
10400
            out = asciilib_rsplit(
inline
                  
asciilib_rsplit can be inlined into rsplit with cost=-12735 (threshold=325) 
rsplit
inline
                  
asciilib_rsplit inlined into rsplit 
rsplit
10401
                self,  buf1, len1, buf2, len2, maxcount);
10402
        else
10403
            out = ucs1lib_rsplit(
inline
                  
ucs1lib_rsplit can be inlined into rsplit with cost=-13555 (threshold=325) 
rsplit
inline
                  
ucs1lib_rsplit inlined into rsplit 
rsplit
10404
                self,  buf1, len1, buf2, len2, maxcount);
10405
        break;
10406
    case PyUnicode_2BYTE_KIND:
10407
        out = ucs2lib_rsplit(
inline
              
ucs2lib_rsplit can be inlined into rsplit with cost=-13555 (threshold=325) 
rsplit
inline
              
ucs2lib_rsplit inlined into rsplit 
rsplit
10408
            self,  buf1, len1, buf2, len2, maxcount);
10409
        break;
10410
    case PyUnicode_4BYTE_KIND:
10411
        out = ucs4lib_rsplit(
inline
              
ucs4lib_rsplit can be inlined into rsplit with cost=-13555 (threshold=325) 
rsplit
inline
              
ucs4lib_rsplit inlined into rsplit 
rsplit
10412
            self,  buf1, len1, buf2, len2, maxcount);
10413
        break;
10414
    default:
10415
        out = NULL;
10416
    }
10417
    if (kind2 != kind1)
10418
        PyMem_Free(buf2);
inline
        
PyMem_Free will not be inlined into rsplit because its definition is unavailable 
rsplit
10419
    return out;
10420
}
10421
10422
static Py_ssize_t
10423
anylib_find(int kind, PyObject *str1, void *buf1, Py_ssize_t len1,
10424
            PyObject *str2, void *buf2, Py_ssize_t len2, Py_ssize_t offset)
10425
{
10426
    switch (kind) {
10427
    case PyUnicode_1BYTE_KIND:
10428
        if (PyUnicode_IS_ASCII(str1) && PyUnicode_IS_ASCII(str2))
10429
            return asciilib_find(buf1, len1, buf2, len2, offset);
inline
                   
asciilib_find can be inlined into anylib_find with cost=-14970 (threshold=325) 
anylib_find
inline
                   
asciilib_find inlined into anylib_find 
anylib_find
10430
        else
10431
            return ucs1lib_find(buf1, len1, buf2, len2, offset);
inline
                   
ucs1lib_find can be inlined into anylib_find with cost=-14970 (threshold=325) 
anylib_find
inline
                   
ucs1lib_find inlined into anylib_find 
anylib_find
10432
    case PyUnicode_2BYTE_KIND:
10433
        return ucs2lib_find(buf1, len1, buf2, len2, offset);
inline
               
ucs2lib_find can be inlined into anylib_find with cost=-14970 (threshold=325) 
anylib_find
inline
               
ucs2lib_find inlined into anylib_find 
anylib_find
10434
    case PyUnicode_4BYTE_KIND:
10435
        return ucs4lib_find(buf1, len1, buf2, len2, offset);
inline
               
ucs4lib_find can be inlined into anylib_find with cost=-14970 (threshold=325) 
anylib_find
inline
               
ucs4lib_find inlined into anylib_find 
anylib_find
10436
    }
10437
    assert(0);
10438
    return -1;
10439
}
10440
10441
static Py_ssize_t
10442
anylib_count(int kind, PyObject *sstr, void* sbuf, Py_ssize_t slen,
10443
             PyObject *str1, void *buf1, Py_ssize_t len1, Py_ssize_t maxcount)
10444
{
10445
    switch (kind) {
10446
    case PyUnicode_1BYTE_KIND:
10447
        if (PyUnicode_IS_ASCII(sstr) && PyUnicode_IS_ASCII(str1))
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
replace
gvn
                                        
load of type i32 not eliminated in favor of load because it is clobbered by call 
replace
10448
            return asciilib_count(sbuf, slen, buf1, len1, maxcount);
inline
                   
asciilib_count can be inlined into anylib_count with cost=-14950 (threshold=325) 
anylib_count
inline
                   
asciilib_count inlined into anylib_count 
anylib_count
10449
        else
10450
            return ucs1lib_count(sbuf, slen, buf1, len1, maxcount);
inline
                   
ucs1lib_count can be inlined into anylib_count with cost=50 (threshold=325) 
anylib_count
inline
                   
ucs1lib_count inlined into anylib_count 
anylib_count
10451
    case PyUnicode_2BYTE_KIND:
10452
        return ucs2lib_count(sbuf, slen, buf1, len1, maxcount);
inline
               
ucs2lib_count can be inlined into anylib_count with cost=50 (threshold=325) 
anylib_count
inline
               
ucs2lib_count inlined into anylib_count 
anylib_count
10453
    case PyUnicode_4BYTE_KIND:
10454
        return ucs4lib_count(sbuf, slen, buf1, len1, maxcount);
inline
               
ucs4lib_count can be inlined into anylib_count with cost=50 (threshold=325) 
anylib_count
inline
               
ucs4lib_count inlined into anylib_count 
anylib_count
10455
    }
10456
    assert(0);
10457
    return 0;
10458
}
10459
10460
static void
10461
replace_1char_inplace(PyObject *u, Py_ssize_t pos,
10462
                      Py_UCS4 u1, Py_UCS4 u2, Py_ssize_t maxcount)
10463
{
10464
    int kind = PyUnicode_KIND(u);
gvn
               
load of type i32 not eliminated because it is clobbered by call 
replace
10465
    void *data = PyUnicode_DATA(u);
gvn
                 
load of type i8* not eliminated because it is clobbered by call 
replace
10466
    Py_ssize_t len = PyUnicode_GET_LENGTH(u);
gvn
                     
load of type i64 not eliminated because it is clobbered by call 
replace
10467
    if (kind == PyUnicode_1BYTE_KIND) {
10468
        ucs1lib_replace_1char_inplace((Py_UCS1 *)data + pos,
inline
        
ucs1lib_replace_1char_inplace can be inlined into replace_1char_inplace with cost=-14625 (threshold=325) 
replace_1char_inplace
inline
        
ucs1lib_replace_1char_inplace inlined into replace_1char_inplace 
replace_1char_inplace
10469
                                      (Py_UCS1 *)data + len,
10470
                                      u1, u2, maxcount);
10471
    }
10472
    else if (kind == PyUnicode_2BYTE_KIND) {
10473
        ucs2lib_replace_1char_inplace((Py_UCS2 *)data + pos,
inline
        
ucs2lib_replace_1char_inplace can be inlined into replace_1char_inplace with cost=-14070 (threshold=325) 
replace_1char_inplace
inline
        
ucs2lib_replace_1char_inplace inlined into replace_1char_inplace 
replace_1char_inplace
10474
                                      (Py_UCS2 *)data + len,
10475
                                      u1, u2, maxcount);
10476
    }
10477
    else {
10478
        assert(kind == PyUnicode_4BYTE_KIND);
10479
        ucs4lib_replace_1char_inplace((Py_UCS4 *)data + pos,
inline
        
ucs4lib_replace_1char_inplace can be inlined into replace_1char_inplace with cost=-14185 (threshold=325) 
replace_1char_inplace
inline
        
ucs4lib_replace_1char_inplace inlined into replace_1char_inplace 
replace_1char_inplace
10480
                                      (Py_UCS4 *)data + len,
10481
                                      u1, u2, maxcount);
10482
    }
10483
}
10484
10485
static PyObject *
10486
replace(PyObject *self, PyObject *str1,
10487
        PyObject *str2, Py_ssize_t maxcount)
10488
{
10489
    PyObject *u;
10490
    char *sbuf = PyUnicode_DATA(self);
10491
    char *buf1 = PyUnicode_DATA(str1);
10492
    char *buf2 = PyUnicode_DATA(str2);
10493
    int srelease = 0, release1 = 0, release2 = 0;
10494
    int skind = PyUnicode_KIND(self);
gvn
                
load of type i32 eliminated in favor of load 
replace
10495
    int kind1 = PyUnicode_KIND(str1);
gvn
                
load of type i32 eliminated in favor of load 
replace
10496
    int kind2 = PyUnicode_KIND(str2);
10497
    Py_ssize_t slen = PyUnicode_GET_LENGTH(self);
10498
    Py_ssize_t len1 = PyUnicode_GET_LENGTH(str1);
10499
    Py_ssize_t len2 = PyUnicode_GET_LENGTH(str2);
10500
    int mayshrink;
10501
    Py_UCS4 maxchar, maxchar_str1, maxchar_str2;
10502
10503
    if (maxcount < 0)
10504
        maxcount = PY_SSIZE_T_MAX;
10505
    else if (maxcount == 0 || slen == 0)
10506
        goto nothing;
10507
10508
    if (str1 == str2)
10509
        goto nothing;
10510
10511
    maxchar = PyUnicode_MAX_CHAR_VALUE(self);
10512
    maxchar_str1 = PyUnicode_MAX_CHAR_VALUE(str1);
gvn
                   
load of type i32 eliminated in favor of load 
replace
10513
    if (maxchar < maxchar_str1)
10514
        /* substring too wide to be present */
10515
        goto nothing;
10516
    maxchar_str2 = PyUnicode_MAX_CHAR_VALUE(str2);
gvn
                   
load of type i32 eliminated in favor of load 
replace
10517
    /* Replacing str1 with str2 may cause a maxchar reduction in the
10518
       result string. */
10519
    mayshrink = (maxchar_str2 < maxchar_str1) && (maxchar == maxchar_str1);
10520
    maxchar = Py_MAX(maxchar, maxchar_str2);
10521
10522
    if (len1 == len2) {
10523
        /* same length */
10524
        if (len1 == 0)
10525
            goto nothing;
10526
        if (len1 == 1) {
10527
            /* replace characters */
10528
            Py_UCS4 u1, u2;
10529
            Py_ssize_t pos;
10530
10531
            u1 = PyUnicode_READ(kind1, buf1, 0);
10532
            pos = findchar(sbuf, skind, slen, u1, 1);
inline
                  
findchar can be inlined into replace with cost=-14870 (threshold=325) 
replace
inline
                  
findchar inlined into replace 
replace
10533
            if (pos < 0)
10534
                goto nothing;
10535
            u2 = PyUnicode_READ(kind2, buf2, 0);
10536
            u = PyUnicode_New(slen, maxchar);
inline
                
PyUnicode_New too costly to inline (cost=460, threshold=250) 
replace
inline
                
PyUnicode_New will not be inlined into replace 
replace
10537
            if (!u)
10538
                goto error;
10539
10540
            _PyUnicode_FastCopyCharacters(u, 0, self, 0, slen);
inline
            
_PyUnicode_FastCopyCharacters can be inlined into replace with cost=5 (threshold=375) 
replace
inline
            
_PyUnicode_FastCopyCharacters inlined into replace 
replace
10541
            replace_1char_inplace(u, pos, u1, u2, maxcount);
inline
            
replace_1char_inplace can be inlined into replace with cost=-12675 (threshold=250) 
replace
inline
            
replace_1char_inplace inlined into replace 
replace
10542
        }
10543
        else {
10544
            int rkind = skind;
10545
            char *res;
10546
            Py_ssize_t i;
10547
10548
            if (kind1 < rkind) {
10549
                /* widen substring */
10550
                buf1 = _PyUnicode_AsKind(str1, rkind);
inline
                       
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
replace
inline
                       
_PyUnicode_AsKind will not be inlined into replace 
replace
10551
                if (!buf1) goto error;
10552
                release1 = 1;
10553
            }
10554
            i = anylib_find(rkind, self, sbuf, slen, str1, buf1, len1, 0);
inline
                
anylib_find too costly to inline (cost=330, threshold=250) 
replace
inline
                
anylib_find will not be inlined into replace 
replace
10555
            if (i < 0)
10556
                goto nothing;
10557
            if (rkind > kind2) {
10558
                /* widen replacement */
10559
                buf2 = _PyUnicode_AsKind(str2, rkind);
inline
                       
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
replace
inline
                       
_PyUnicode_AsKind will not be inlined into replace 
replace
10560
                if (!buf2) goto error;
10561
                release2 = 1;
10562
            }
10563
            else if (rkind < kind2) {
10564
                /* widen self and buf1 */
10565
                rkind = kind2;
10566
                if (release1) PyMem_Free(buf1);
inline
                              
PyMem_Free will not be inlined into replace because its definition is unavailable 
replace
10567
                release1 = 0;
10568
                sbuf = _PyUnicode_AsKind(self, rkind);
inline
                       
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
replace
inline
                       
_PyUnicode_AsKind will not be inlined into replace 
replace
10569
                if (!sbuf) goto error;
10570
                srelease = 1;
10571
                buf1 = _PyUnicode_AsKind(str1, rkind);
inline
                       
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
replace
inline
                       
_PyUnicode_AsKind will not be inlined into replace 
replace
10572
                if (!buf1) goto error;
10573
                release1 = 1;
10574
            }
10575
            u = PyUnicode_New(slen, maxchar);
inline
                
PyUnicode_New too costly to inline (cost=460, threshold=250) 
replace
inline
                
PyUnicode_New will not be inlined into replace 
replace
10576
            if (!u)
10577
                goto error;
10578
            assert(PyUnicode_KIND(u) == rkind);
10579
            res = PyUnicode_DATA(u);
gvn
                  
load of type i32 not eliminated because it is clobbered by call 
replace
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
replace
10580
10581
            memcpy(res, sbuf, rkind * slen);
10582
            /* change everything in-place, starting with this one */
10583
            memcpy(res + rkind * i,
10584
                   buf2,
10585
                   rkind * len2);
10586
            i += len1;
10587
10588
            while ( --maxcount > 0) {
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
replace
loop-vectorize
            
loop not vectorized 
replace
10589
                i = anylib_find(rkind, self,
inline
                    
anylib_find too costly to inline (cost=330, threshold=250) 
replace
inline
                    
anylib_find will not be inlined into replace 
replace
10590
                                sbuf+rkind*i, slen-i,
10591
                                str1, buf1, len1, i);
10592
                if (i == -1)
10593
                    break;
10594
                memcpy(res + rkind * i,
10595
                       buf2,
10596
                       rkind * len2);
10597
                i += len1;
10598
            }
10599
        }
10600
    }
10601
    else {
10602
        Py_ssize_t n, i, j, ires;
10603
        Py_ssize_t new_size;
10604
        int rkind = skind;
10605
        char *res;
10606
10607
        if (kind1 < rkind) {
10608
            /* widen substring */
10609
            buf1 = _PyUnicode_AsKind(str1, rkind);
inline
                   
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
replace
inline
                   
_PyUnicode_AsKind will not be inlined into replace 
replace
10610
            if (!buf1) goto error;
10611
            release1 = 1;
10612
        }
10613
        n = anylib_count(rkind, self, sbuf, slen, str1, buf1, len1, maxcount);
inline
            
anylib_count can be inlined into replace with cost=-14290 (threshold=250) 
replace
inline
            
anylib_count inlined into replace 
replace
10614
        if (n == 0)
10615
            goto nothing;
10616
        if (kind2 < rkind) {
10617
            /* widen replacement */
10618
            buf2 = _PyUnicode_AsKind(str2, rkind);
inline
                   
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
replace
inline
                   
_PyUnicode_AsKind will not be inlined into replace 
replace
10619
            if (!buf2) goto error;
10620
            release2 = 1;
10621
        }
10622
        else if (kind2 > rkind) {
10623
            /* widen self and buf1 */
10624
            rkind = kind2;
10625
            sbuf = _PyUnicode_AsKind(self, rkind);
inline
                   
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
replace
inline
                   
_PyUnicode_AsKind will not be inlined into replace 
replace
10626
            if (!sbuf) goto error;
10627
            srelease = 1;
10628
            if (release1) PyMem_Free(buf1);
inline
                          
PyMem_Free will not be inlined into replace because its definition is unavailable 
replace
10629
            release1 = 0;
10630
            buf1 = _PyUnicode_AsKind(str1, rkind);
inline
                   
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
replace
inline
                   
_PyUnicode_AsKind will not be inlined into replace 
replace
10631
            if (!buf1) goto error;
10632
            release1 = 1;
10633
        }
10634
        /* new_size = PyUnicode_GET_LENGTH(self) + n * (PyUnicode_GET_LENGTH(str2) -
10635
           PyUnicode_GET_LENGTH(str1))); */
10636
        if (len1 < len2 && len2 - len1 > (PY_SSIZE_T_MAX - slen) / n) {
10637
                PyErr_SetString(PyExc_OverflowError,
inline
                
PyErr_SetString will not be inlined into replace because its definition is unavailable 
replace
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
replace
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
replace
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
replace
10638
                                "replace string is too long");
10639
                goto error;
10640
        }
10641
        new_size = slen + n * (len2 - len1);
10642
        if (new_size == 0) {
10643
            _Py_INCREF_UNICODE_EMPTY();
inline
            
PyUnicode_New too costly to inline (cost=290, threshold=250) 
replace
inline
            
PyUnicode_New will not be inlined into replace 
replace
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
replace
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
replace
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
replace
10644
            if (!unicode_empty)
10645
                goto error;
10646
            u = unicode_empty;
10647
            goto done;
10648
        }
10649
        if (new_size > (PY_SSIZE_T_MAX >> (rkind-1))) {
10650
            PyErr_SetString(PyExc_OverflowError,
inline
            
PyErr_SetString will not be inlined into replace because its definition is unavailable 
replace
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
replace
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
replace
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
replace
10651
                            "replace string is too long");
10652
            goto error;
10653
        }
10654
        u = PyUnicode_New(new_size, maxchar);
inline
            
PyUnicode_New too costly to inline (cost=460, threshold=250) 
replace
inline
            
PyUnicode_New will not be inlined into replace 
replace
10655
        if (!u)
10656
            goto error;
10657
        assert(PyUnicode_KIND(u) == rkind);
10658
        res = PyUnicode_DATA(u);
gvn
              
load of type i32 not eliminated because it is clobbered by call 
replace
gvn
              
load of type i8* not eliminated because it is clobbered by call 
replace
10659
        ires = i = 0;
10660
        if (len1 > 0) {
10661
            while (n-- > 0) {
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
replace
loop-vectorize
            
loop not vectorized 
replace
10662
                /* look for next match */
10663
                j = anylib_find(rkind, self,
inline
                    
anylib_find too costly to inline (cost=330, threshold=250) 
replace
inline
                    
anylib_find will not be inlined into replace 
replace
10664
                                sbuf + rkind * i, slen-i,
10665
                                str1, buf1, len1, i);
10666
                if (j == -1)
10667
                    break;
10668
                else if (j > i) {
10669
                    /* copy unchanged part [i:j] */
10670
                    memcpy(res + rkind * ires,
10671
                           sbuf + rkind * i,
10672
                           rkind * (j-i));
10673
                    ires += j - i;
10674
                }
10675
                /* copy substitution string */
10676
                if (len2 > 0) {
licm
                         
hosting icmp 
replace
10677
                    memcpy(res + rkind * ires,
10678
                           buf2,
10679
                           rkind * len2);
licm
                                 
hosting mul 
replace
10680
                    ires += len2;
10681
                }
10682
                i = j + len1;
10683
            }
10684
            if (i < slen)
10685
                /* copy tail [i:] */
10686
                memcpy(res + rkind * ires,
10687
                       sbuf + rkind * i,
10688
                       rkind * (slen-i));
10689
        }
10690
        else {
10691
            /* interleave */
10692
            while (n > 0) {
10693
                memcpy(res + rkind * ires,
10694
                       buf2,
10695
                       rkind * len2);
licm
                             
hosting mul 
replace
10696
                ires += len2;
10697
                if (--n <= 0)
loop-vectorize
                    
loop not vectorized 
replace
10698
                    break;
10699
                memcpy(res + rkind * ires,
loop-vectorize
                
loop not vectorized: call instruction cannot be vectorized 
replace
loop-unroll
                                   
unrolled loop by a factor of 2 with run-time trip count 
replace
10700
                       sbuf + rkind * i,
10701
                       rkind);
10702
                ires++;
10703
                i++;
10704
            }
10705
            memcpy(res + rkind * ires,
10706
                   sbuf + rkind * i,
10707
                   rkind * (slen-i));
10708
        }
10709
    }
10710
10711
    if (mayshrink) {
10712
        unicode_adjust_maxchar(&u);
inline
        
unicode_adjust_maxchar can be inlined into replace with cost=-14270 (threshold=250) 
replace
inline
        
unicode_adjust_maxchar inlined into replace 
replace
10713
        if (u == NULL)
10714
            goto error;
10715
    }
10716
10717
  done:
10718
    if (srelease)
10719
        PyMem_FREE(sbuf);
inline
        
PyMem_Free will not be inlined into replace because its definition is unavailable 
replace
10720
    if (release1)
10721
        PyMem_FREE(buf1);
inline
        
PyMem_Free will not be inlined into replace because its definition is unavailable 
replace
10722
    if (release2)
10723
        PyMem_FREE(buf2);
inline
        
PyMem_Free will not be inlined into replace because its definition is unavailable 
replace
10724
    assert(_PyUnicode_CheckConsistency(u, 1));
10725
    return u;
10726
10727
  nothing:
10728
    /* nothing to replace; return original string (when possible) */
10729
    if (srelease)
10730
        PyMem_FREE(sbuf);
inline
        
PyMem_Free will not be inlined into replace because its definition is unavailable 
replace
10731
    if (release1)
10732
        PyMem_FREE(buf1);
inline
        
PyMem_Free will not be inlined into replace because its definition is unavailable 
replace
10733
    if (release2)
10734
        PyMem_FREE(buf2);
inline
        
PyMem_Free will not be inlined into replace because its definition is unavailable 
replace
10735
    return unicode_result_unchanged(self);
inline
           
unicode_result_unchanged can be inlined into replace with cost=90 (threshold=250) 
replace
inline
           
unicode_result_unchanged inlined into replace 
replace
10736
10737
  error:
10738
    if (srelease && sbuf)
10739
        PyMem_FREE(sbuf);
inline
        
PyMem_Free will not be inlined into replace because its definition is unavailable 
replace
10740
    if (release1 && buf1)
10741
        PyMem_FREE(buf1);
inline
        
PyMem_Free will not be inlined into replace because its definition is unavailable 
replace
10742
    if (release2 && buf2)
10743
        PyMem_FREE(buf2);
inline
        
PyMem_Free will not be inlined into replace because its definition is unavailable 
replace
10744
    return NULL;
10745
}
10746
10747
/* --- Unicode Object Methods --------------------------------------------- */
10748
10749
PyDoc_STRVAR(title__doc__,
10750
             "S.title() -> str\n\
10751
\n\
10752
Return a titlecased version of S, i.e. words start with title case\n\
10753
characters, all remaining cased characters have lower case.");
10754
10755
static PyObject*
10756
unicode_title(PyObject *self)
10757
{
10758
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_title
inline
        
_PyUnicode_Ready will not be inlined into unicode_title 
unicode_title
10759
        return NULL;
10760
    return case_operation(self, do_title);
inline
           
case_operation too costly to inline (cost=580, threshold=250) 
unicode_title
inline
           
case_operation will not be inlined into unicode_title 
unicode_title
10761
}
10762
10763
PyDoc_STRVAR(capitalize__doc__,
10764
             "S.capitalize() -> str\n\
10765
\n\
10766
Return a capitalized version of S, i.e. make the first character\n\
10767
have upper case and the rest lower case.");
10768
10769
static PyObject*
10770
unicode_capitalize(PyObject *self)
10771
{
10772
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_capitalize
inline
        
_PyUnicode_Ready will not be inlined into unicode_capitalize 
unicode_capitalize
10773
        return NULL;
10774
    if (PyUnicode_GET_LENGTH(self) == 0)
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_capitalize
10775
        return unicode_result_unchanged(self);
inline
               
unicode_result_unchanged can be inlined into unicode_capitalize with cost=90 (threshold=250) 
unicode_capitalize
inline
               
unicode_result_unchanged inlined into unicode_capitalize 
unicode_capitalize
10776
    return case_operation(self, do_capitalize);
inline
           
case_operation too costly to inline (cost=580, threshold=250) 
unicode_capitalize
inline
           
case_operation will not be inlined into unicode_capitalize 
unicode_capitalize
10777
}
10778
10779
PyDoc_STRVAR(casefold__doc__,
10780
             "S.casefold() -> str\n\
10781
\n\
10782
Return a version of S suitable for caseless comparisons.");
10783
10784
static PyObject *
10785
unicode_casefold(PyObject *self)
10786
{
10787
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_casefold
inline
        
_PyUnicode_Ready will not be inlined into unicode_casefold 
unicode_casefold
10788
        return NULL;
10789
    if (PyUnicode_IS_ASCII(self))
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_casefold
gvn
        
load eliminated by PRE 
unicode_casefold
10790
        return ascii_upper_or_lower(self, 1);
inline
               
ascii_upper_or_lower can be inlined into unicode_casefold with cost=140 (threshold=250) 
unicode_casefold
inline
               
ascii_upper_or_lower inlined into unicode_casefold 
unicode_casefold
10791
    return case_operation(self, do_casefold);
inline
           
case_operation too costly to inline (cost=580, threshold=250) 
unicode_casefold
inline
           
case_operation will not be inlined into unicode_casefold 
unicode_casefold
10792
}
10793
10794
10795
/* Argument converter. Accepts a single Unicode character. */
10796
10797
static int
10798
convert_uc(PyObject *obj, void *addr)
10799
{
10800
    Py_UCS4 *fillcharloc = (Py_UCS4 *)addr;
10801
10802
    if (!PyUnicode_Check(obj)) {
10803
        PyErr_Format(PyExc_TypeError,
inline
        
PyErr_Format will not be inlined into convert_uc because its definition is unavailable 
convert_uc
10804
                     "The fill character must be a unicode character, "
10805
                     "not %.100s", Py_TYPE(obj)->tp_name);
10806
        return 0;
10807
    }
10808
    if (PyUnicode_READY(obj) < 0)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
convert_uc
inline
        
_PyUnicode_Ready will not be inlined into convert_uc 
convert_uc
10809
        return 0;
10810
    if (PyUnicode_GET_LENGTH(obj) != 1) {
gvn
        
load of type i64 not eliminated because it is clobbered by call 
convert_uc
10811
        PyErr_SetString(PyExc_TypeError,
inline
        
PyErr_SetString will not be inlined into convert_uc because its definition is unavailable 
convert_uc
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
convert_uc
10812
                        "The fill character must be exactly one character long");
10813
        return 0;
10814
    }
10815
    *fillcharloc = PyUnicode_READ_CHAR(obj, 0);
gvn
                   
load of type i32 not eliminated in favor of load because it is clobbered by call 
convert_uc
gvn
                   
load of type i8* not eliminated because it is clobbered by call 
convert_uc
10816
    return 1;
10817
}
10818
10819
PyDoc_STRVAR(center__doc__,
10820
             "S.center(width[, fillchar]) -> str\n\
10821
\n\
10822
Return S centered in a string of length width. Padding is\n\
10823
done using the specified fill character (default is a space)");
10824
10825
static PyObject *
10826
unicode_center(PyObject *self, PyObject *args)
10827
{
10828
    Py_ssize_t marg, left;
10829
    Py_ssize_t width;
10830
    Py_UCS4 fillchar = ' ';
10831
10832
    if (!PyArg_ParseTuple(args, "n|O&:center", &width, convert_uc, &fillchar))
inline
         
_PyArg_ParseTuple_SizeT will not be inlined into unicode_center because its definition is unavailable 
unicode_center
10833
        return NULL;
10834
10835
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_center
inline
        
_PyUnicode_Ready will not be inlined into unicode_center 
unicode_center
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_center
10836
        return NULL;
10837
10838
    if (PyUnicode_GET_LENGTH(self) >= width)
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_center
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_center
gvn
                                      
load of type i64 not eliminated because it is clobbered by call 
unicode_center
gvn
                                      
load of type i64 not eliminated because it is clobbered by call 
unicode_center
10839
        return unicode_result_unchanged(self);
inline
               
unicode_result_unchanged can be inlined into unicode_center with cost=90 (threshold=250) 
unicode_center
inline
               
unicode_result_unchanged inlined into unicode_center 
unicode_center
10840
10841
    marg = width - PyUnicode_GET_LENGTH(self);
10842
    left = marg / 2 + (marg & width & 1);
10843
10844
    return pad(self, left, marg - left, fillchar);
inline
           
pad too costly to inline (cost=620, threshold=250) 
unicode_center
inline
           
pad will not be inlined into unicode_center 
unicode_center
gvn
                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_center
gvn
                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_center
10845
}
10846
10847
/* This function assumes that str1 and str2 are readied by the caller. */
10848
10849
static int
10850
unicode_compare(PyObject *str1, PyObject *str2)
10851
{
10852
#define COMPARE(TYPE1, TYPE2) \
10853
    do { \
10854
        TYPE1* p1 = (TYPE1 *)data1; \
10855
        TYPE2* p2 = (TYPE2 *)data2; \
10856
        TYPE1* end = p1 + len; \
10857
        Py_UCS4 c1, c2; \
10858
        for (; p1 != end; p1++, p2++) { \
10859
            c1 = *p1; \
10860
            c2 = *p2; \
10861
            if (c1 != c2) \
10862
                return (c1 < c2) ? -1 : 1; \
10863
        } \
10864
    } \
10865
    while (0)
10866
10867
    int kind1, kind2;
10868
    void *data1, *data2;
10869
    Py_ssize_t len1, len2, len;
10870
10871
    kind1 = PyUnicode_KIND(str1);
10872
    kind2 = PyUnicode_KIND(str2);
10873
    data1 = PyUnicode_DATA(str1);
10874
    data2 = PyUnicode_DATA(str2);
10875
    len1 = PyUnicode_GET_LENGTH(str1);
10876
    len2 = PyUnicode_GET_LENGTH(str2);
10877
    len = Py_MIN(len1, len2);
10878
10879
    switch(kind1) {
10880
    case PyUnicode_1BYTE_KIND:
10881
    {
10882
        switch(kind2) {
10883
        case PyUnicode_1BYTE_KIND:
10884
        {
10885
            int cmp = memcmp(data1, data2, len);
inline
                      
memcmp will not be inlined into unicode_compare because its definition is unavailable 
unicode_compare
10886
            /* normalize result of memcmp() into the range [-1; 1] */
10887
            if (cmp < 0)
10888
                return -1;
10889
            if (cmp > 0)
10890
                return 1;
10891
            break;
10892
        }
10893
        case PyUnicode_2BYTE_KIND:
10894
            COMPARE(Py_UCS1, Py_UCS2);
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_compare
loop-vectorize
            
loop not vectorized 
unicode_compare
10895
            break;
10896
        case PyUnicode_4BYTE_KIND:
10897
            COMPARE(Py_UCS1, Py_UCS4);
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_compare
loop-vectorize
            
loop not vectorized 
unicode_compare
10898
            break;
10899
        default:
10900
            assert(0);
10901
        }
10902
        break;
10903
    }
10904
    case PyUnicode_2BYTE_KIND:
10905
    {
10906
        switch(kind2) {
10907
        case PyUnicode_1BYTE_KIND:
10908
            COMPARE(Py_UCS2, Py_UCS1);
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_compare
loop-vectorize
            
loop not vectorized 
unicode_compare
10909
            break;
10910
        case PyUnicode_2BYTE_KIND:
10911
        {
10912
            COMPARE(Py_UCS2, Py_UCS2);
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_compare
loop-vectorize
            
loop not vectorized 
unicode_compare
10913
            break;
10914
        }
10915
        case PyUnicode_4BYTE_KIND:
10916
            COMPARE(Py_UCS2, Py_UCS4);
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_compare
loop-vectorize
            
loop not vectorized 
unicode_compare
10917
            break;
10918
        default:
10919
            assert(0);
10920
        }
10921
        break;
10922
    }
10923
    case PyUnicode_4BYTE_KIND:
10924
    {
10925
        switch(kind2) {
10926
        case PyUnicode_1BYTE_KIND:
10927
            COMPARE(Py_UCS4, Py_UCS1);
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_compare
loop-vectorize
            
loop not vectorized 
unicode_compare
10928
            break;
10929
        case PyUnicode_2BYTE_KIND:
10930
            COMPARE(Py_UCS4, Py_UCS2);
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_compare
loop-vectorize
            
loop not vectorized 
unicode_compare
10931
            break;
10932
        case PyUnicode_4BYTE_KIND:
10933
        {
10934
#if defined(HAVE_WMEMCMP) && SIZEOF_WCHAR_T == 4
10935
            int cmp = wmemcmp((wchar_t *)data1, (wchar_t *)data2, len);
inline
                      
wmemcmp will not be inlined into unicode_compare because its definition is unavailable 
unicode_compare
10936
            /* normalize result of wmemcmp() into the range [-1; 1] */
10937
            if (cmp < 0)
10938
                return -1;
10939
            if (cmp > 0)
10940
                return 1;
10941
#else
10942
            COMPARE(Py_UCS4, Py_UCS4);
10943
#endif
10944
            break;
10945
        }
10946
        default:
10947
            assert(0);
10948
        }
10949
        break;
10950
    }
10951
    default:
10952
        assert(0);
10953
    }
10954
10955
    if (len1 == len2)
10956
        return 0;
10957
    if (len1 < len2)
10958
        return -1;
10959
    else
10960
        return 1;
10961
10962
#undef COMPARE
10963
}
10964
10965
static int
10966
unicode_compare_eq(PyObject *str1, PyObject *str2)
10967
{
10968
    int kind;
10969
    void *data1, *data2;
10970
    Py_ssize_t len;
10971
    int cmp;
10972
10973
    len = PyUnicode_GET_LENGTH(str1);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIId
gvn
          
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIId
gvn
          
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_RichCompare
gvn
          
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_RichCompare
10974
    if (PyUnicode_GET_LENGTH(str2) != len)
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_RichCompare
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_RichCompare
10975
        return 0;
10976
    kind = PyUnicode_KIND(str1);
gvn
           
load of type i32 eliminated in favor of load 
_PyUnicode_EqualToASCIIId
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_RichCompare
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_RichCompare
10977
    if (PyUnicode_KIND(str2) != kind)
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_RichCompare
10978
        return 0;
10979
    data1 = PyUnicode_DATA(str1);
gvn
            
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_EqualToASCIIId
gvn
            
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIId
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_RichCompare
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_RichCompare
10980
    data2 = PyUnicode_DATA(str2);
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_RichCompare
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_RichCompare
10981
10982
    cmp = memcmp(data1, data2, len * kind);
inline
          
memcmp will not be inlined into unicode_compare_eq because its definition is unavailable 
unicode_compare_eq
10983
    return (cmp == 0);
10984
}
10985
10986
10987
int
10988
PyUnicode_Compare(PyObject *left, PyObject *right)
10989
{
10990
    if (PyUnicode_Check(left) && PyUnicode_Check(right)) {
10991
        if (PyUnicode_READY(left) == -1 ||
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Compare
inline
            
_PyUnicode_Ready will not be inlined into PyUnicode_Compare 
PyUnicode_Compare
10992
            PyUnicode_READY(right) == -1)
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Compare
inline
            
_PyUnicode_Ready will not be inlined into PyUnicode_Compare 
PyUnicode_Compare
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Compare
10993
            return -1;
10994
10995
        /* a string is equal to itself */
10996
        if (left == right)
10997
            return 0;
10998
10999
        return unicode_compare(left, right);
inline
               
unicode_compare too costly to inline (cost=630, threshold=625) 
PyUnicode_Compare
inline
               
unicode_compare will not be inlined into PyUnicode_Compare 
PyUnicode_Compare
11000
    }
11001
    PyErr_Format(PyExc_TypeError,
inline
    
PyErr_Format will not be inlined into PyUnicode_Compare because its definition is unavailable 
PyUnicode_Compare
11002
                 "Can't compare %.100s and %.100s",
11003
                 left->ob_type->tp_name,
11004
                 right->ob_type->tp_name);
11005
    return -1;
11006
}
11007
11008
int
11009
PyUnicode_CompareWithASCIIString(PyObject* uni, const char* str)
11010
{
11011
    Py_ssize_t i;
11012
    int kind;
11013
    Py_UCS4 chr;
11014
    const unsigned char *ustr = (const unsigned char *)str;
11015
11016
    assert(_PyUnicode_CHECK(uni));
11017
    if (!PyUnicode_IS_READY(uni)) {
11018
        const wchar_t *ws = _PyUnicode_WSTR(uni);
11019
        /* Compare Unicode string and source character set string */
11020
        for (i = 0; (chr = ws[i]) && ustr[i]; i++) {
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_CompareWithASCIIString
loop-vectorize
        
loop not vectorized 
PyUnicode_CompareWithASCIIString
11021
            if (chr != ustr[i])
11022
                return (chr < ustr[i]) ? -1 : 1;
11023
        }
11024
        /* This check keeps Python strings that end in '\0' from comparing equal
11025
         to C strings identical up to that point. */
11026
        if (_PyUnicode_WSTR_LENGTH(uni) != i || chr)
11027
            return 1; /* uni is longer */
11028
        if (ustr[i])
11029
            return -1; /* str is longer */
11030
        return 0;
11031
    }
11032
    kind = PyUnicode_KIND(uni);
11033
    if (kind == PyUnicode_1BYTE_KIND) {
11034
        const void *data = PyUnicode_1BYTE_DATA(uni);
11035
        size_t len1 = (size_t)PyUnicode_GET_LENGTH(uni);
11036
        size_t len, len2 = strlen(str);
inline
                           
strlen will not be inlined into PyUnicode_CompareWithASCIIString because its definition is unavailable 
PyUnicode_CompareWithASCIIString
11037
        int cmp;
11038
11039
        len = Py_MIN(len1, len2);
11040
        cmp = memcmp(data, str, len);
inline
              
memcmp will not be inlined into PyUnicode_CompareWithASCIIString because its definition is unavailable 
PyUnicode_CompareWithASCIIString
11041
        if (cmp != 0) {
11042
            if (cmp < 0)
11043
                return -1;
11044
            else
11045
                return 1;
11046
        }
11047
        if (len1 > len2)
11048
            return 1; /* uni is longer */
11049
        if (len1 < len2)
11050
            return -1; /* str is longer */
11051
        return 0;
11052
    }
11053
    else {
11054
        void *data = PyUnicode_DATA(uni);
11055
        /* Compare Unicode string and source character set string */
11056
        for (i = 0; (chr = PyUnicode_READ(kind, data, i)) && str[i]; i++)
licm
                           
hosting icmp 
PyUnicode_CompareWithASCIIString
licm
                           
hosting bitcast 
PyUnicode_CompareWithASCIIString
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_CompareWithASCIIString
loop-vectorize
        
loop not vectorized 
PyUnicode_CompareWithASCIIString
11057
            if (chr != (unsigned char)str[i])
11058
                return (chr < (unsigned char)(str[i])) ? -1 : 1;
11059
        /* This check keeps Python strings that end in '\0' from comparing equal
11060
         to C strings identical up to that point. */
11061
        if (PyUnicode_GET_LENGTH(uni) != i || chr)
11062
            return 1; /* uni is longer */
11063
        if (str[i])
11064
            return -1; /* str is longer */
11065
        return 0;
11066
    }
11067
}
11068
11069
static int
11070
non_ready_unicode_equal_to_ascii_string(PyObject *unicode, const char *str)
11071
{
11072
    size_t i, len;
11073
    const wchar_t *p;
11074
    len = (size_t)_PyUnicode_WSTR_LENGTH(unicode);
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIString
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIId
11075
    if (strlen(str) != len)
inline
        
strlen will not be inlined into non_ready_unicode_equal_to_ascii_string because its definition is unavailable 
non_ready_unicode_equal_to_ascii_string
11076
        return 0;
11077
    p = _PyUnicode_WSTR(unicode);
gvn
        
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIString
gvn
        
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIId
11078
    assert(p);
11079
    for (i = 0; i < len; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_EqualToASCIIString
loop-vectorize
    
loop not vectorized 
_PyUnicode_EqualToASCIIString
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_EqualToASCIIId
loop-vectorize
    
loop not vectorized 
_PyUnicode_EqualToASCIIId
11080
        unsigned char c = (unsigned char)str[i];
gvn
                                         
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIString
gvn
                                         
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIId
11081
        if (c >= 128 || p[i] != (wchar_t)c)
11082
            return 0;
11083
    }
11084
    return 1;
11085
}
11086
11087
int
11088
_PyUnicode_EqualToASCIIString(PyObject *unicode, const char *str)
11089
{
11090
    size_t len;
11091
    assert(_PyUnicode_CHECK(unicode));
11092
    assert(str);
11093
#ifndef NDEBUG
11094
    for (const char *p = str; *p; p++) {
11095
        assert((unsigned char)*p < 128);
11096
    }
11097
#endif
11098
    if (PyUnicode_READY(unicode) == -1) {
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_EqualToASCIIString
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_EqualToASCIIString 
_PyUnicode_EqualToASCIIString
11099
        /* Memory error or bad data */
11100
        PyErr_Clear();
inline
        
PyErr_Clear will not be inlined into _PyUnicode_EqualToASCIIString because its definition is unavailable 
_PyUnicode_EqualToASCIIString
11101
        return non_ready_unicode_equal_to_ascii_string(unicode, str);
inline
               
non_ready_unicode_equal_to_ascii_string can be inlined into _PyUnicode_EqualToASCIIString with cost=85 (threshold=250) 
_PyUnicode_EqualToASCIIString
inline
               
non_ready_unicode_equal_to_ascii_string inlined into _PyUnicode_EqualToASCIIString 
_PyUnicode_EqualToASCIIString
11102
    }
11103
    if (!PyUnicode_IS_ASCII(unicode))
gvn
         
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EqualToASCIIString
gvn
         
load eliminated by PRE 
_PyUnicode_EqualToASCIIString
11104
        return 0;
11105
    len = (size_t)PyUnicode_GET_LENGTH(unicode);
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIString
11106
    return strlen(str) == len &&
inline
           
strlen will not be inlined into _PyUnicode_EqualToASCIIString because its definition is unavailable 
_PyUnicode_EqualToASCIIString
11107
           memcmp(PyUnicode_1BYTE_DATA(unicode), str, len) == 0;
inline
           
memcmp will not be inlined into _PyUnicode_EqualToASCIIString because its definition is unavailable 
_PyUnicode_EqualToASCIIString
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIString
11108
}
11109
11110
int
11111
_PyUnicode_EqualToASCIIId(PyObject *left, _Py_Identifier *right)
11112
{
11113
    PyObject *right_uni;
11114
    Py_hash_t hash;
11115
11116
    assert(_PyUnicode_CHECK(left));
11117
    assert(right->string);
11118
#ifndef NDEBUG
11119
    for (const char *p = right->string; *p; p++) {
11120
        assert((unsigned char)*p < 128);
11121
    }
11122
#endif
11123
11124
    if (PyUnicode_READY(left) == -1) {
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_EqualToASCIIId
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_EqualToASCIIId 
_PyUnicode_EqualToASCIIId
11125
        /* memory error or bad data */
11126
        PyErr_Clear();
inline
        
PyErr_Clear will not be inlined into _PyUnicode_EqualToASCIIId because its definition is unavailable 
_PyUnicode_EqualToASCIIId
11127
        return non_ready_unicode_equal_to_ascii_string(left, right->string);
inline
               
non_ready_unicode_equal_to_ascii_string can be inlined into _PyUnicode_EqualToASCIIId with cost=-14915 (threshold=250) 
_PyUnicode_EqualToASCIIId
inline
               
non_ready_unicode_equal_to_ascii_string inlined into _PyUnicode_EqualToASCIIId 
_PyUnicode_EqualToASCIIId
gvn
                                                                    
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIId
11128
    }
11129
11130
    if (!PyUnicode_IS_ASCII(left))
gvn
         
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EqualToASCIIId
gvn
         
load eliminated by PRE 
_PyUnicode_EqualToASCIIId
11131
        return 0;
11132
11133
    right_uni = _PyUnicode_FromId(right);       /* borrowed */
inline
                
_PyUnicode_FromId can be inlined into _PyUnicode_EqualToASCIIId with cost=140 (threshold=250) 
_PyUnicode_EqualToASCIIId
inline
                
_PyUnicode_FromId inlined into _PyUnicode_EqualToASCIIId 
_PyUnicode_EqualToASCIIId
11134
    if (right_uni == NULL) {
11135
        /* memory error or bad data */
11136
        PyErr_Clear();
inline
        
PyErr_Clear will not be inlined into _PyUnicode_EqualToASCIIId because its definition is unavailable 
_PyUnicode_EqualToASCIIId
11137
        return _PyUnicode_EqualToASCIIString(left, right->string);
inline
               
_PyUnicode_EqualToASCIIString too costly to inline (cost=320, threshold=250) 
_PyUnicode_EqualToASCIIId
inline
               
_PyUnicode_EqualToASCIIString will not be inlined into _PyUnicode_EqualToASCIIId 
_PyUnicode_EqualToASCIIId
gvn
                                                          
load of type i8* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_EqualToASCIIId
11138
    }
11139
11140
    if (left == right_uni)
11141
        return 1;
11142
11143
    if (PyUnicode_CHECK_INTERNED(left))
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by store 
_PyUnicode_EqualToASCIIId
11144
        return 0;
11145
11146
    assert(_PyUnicode_HASH(right_uni) != 1);
11147
    hash = _PyUnicode_HASH(left);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIId
gvn
           
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_EqualToASCIIId
11148
    if (hash != -1 && hash != _PyUnicode_HASH(right_uni))
11149
        return 0;
11150
11151
    return unicode_compare_eq(left, right_uni);
inline
           
unicode_compare_eq can be inlined into _PyUnicode_EqualToASCIIId with cost=145 (threshold=250) 
_PyUnicode_EqualToASCIIId
inline
           
unicode_compare_eq inlined into _PyUnicode_EqualToASCIIId 
_PyUnicode_EqualToASCIIId
11152
}
11153
11154
#define TEST_COND(cond)                         \
11155
    ((cond) ? Py_True : Py_False)
11156
11157
PyObject *
11158
PyUnicode_RichCompare(PyObject *left, PyObject *right, int op)
11159
{
11160
    int result;
11161
    PyObject *v;
11162
11163
    if (!PyUnicode_Check(left) || !PyUnicode_Check(right))
11164
        Py_RETURN_NOTIMPLEMENTED;
11165
11166
    if (PyUnicode_READY(left) == -1 ||
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_RichCompare
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_RichCompare 
PyUnicode_RichCompare
11167
        PyUnicode_READY(right) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_RichCompare
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_RichCompare 
PyUnicode_RichCompare
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_RichCompare
11168
        return NULL;
11169
11170
    if (left == right) {
11171
        switch (op) {
11172
        case Py_EQ:
11173
        case Py_LE:
11174
        case Py_GE:
11175
            /* a string is equal to itself */
11176
            v = Py_True;
11177
            break;
11178
        case Py_NE:
11179
        case Py_LT:
11180
        case Py_GT:
11181
            v = Py_False;
11182
            break;
11183
        default:
11184
            PyErr_BadArgument();
inline
            
PyErr_BadArgument will not be inlined into PyUnicode_RichCompare because its definition is unavailable 
PyUnicode_RichCompare
11185
            return NULL;
11186
        }
11187
    }
11188
    else if (op == Py_EQ || op == Py_NE) {
11189
        result = unicode_compare_eq(left, right);
inline
                 
unicode_compare_eq can be inlined into PyUnicode_RichCompare with cost=-14855 (threshold=250) 
PyUnicode_RichCompare
inline
                 
unicode_compare_eq inlined into PyUnicode_RichCompare 
PyUnicode_RichCompare
11190
        result ^= (op == Py_NE);
11191
        v = TEST_COND(result);
11192
    }
11193
    else {
11194
        result = unicode_compare(left, right);
inline
                 
unicode_compare too costly to inline (cost=630, threshold=625) 
PyUnicode_RichCompare
inline
                 
unicode_compare will not be inlined into PyUnicode_RichCompare 
PyUnicode_RichCompare
11195
11196
        /* Convert the return value to a Boolean */
11197
        switch (op) {
11198
        case Py_LE:
11199
            v = TEST_COND(result <= 0);
11200
            break;
11201
        case Py_GE:
11202
            v = TEST_COND(result >= 0);
11203
            break;
11204
        case Py_LT:
11205
            v = TEST_COND(result == -1);
11206
            break;
11207
        case Py_GT:
11208
            v = TEST_COND(result == 1);
11209
            break;
11210
        default:
11211
            PyErr_BadArgument();
inline
            
PyErr_BadArgument will not be inlined into PyUnicode_RichCompare because its definition is unavailable 
PyUnicode_RichCompare
11212
            return NULL;
11213
        }
11214
    }
11215
    Py_INCREF(v);
11216
    return v;
11217
}
11218
11219
int
11220
_PyUnicode_EQ(PyObject *aa, PyObject *bb)
11221
{
11222
    return unicode_eq(aa, bb);
inline
           
unicode_eq can be inlined into _PyUnicode_EQ with cost=-14725 (threshold=325) 
_PyUnicode_EQ
inline
           
unicode_eq inlined into _PyUnicode_EQ 
_PyUnicode_EQ
11223
}
11224
11225
int
11226
PyUnicode_Contains(PyObject *str, PyObject *substr)
11227
{
11228
    int kind1, kind2;
11229
    void *buf1, *buf2;
11230
    Py_ssize_t len1, len2;
11231
    int result;
11232
11233
    if (!PyUnicode_Check(substr)) {
11234
        PyErr_Format(PyExc_TypeError,
inline
        
PyErr_Format will not be inlined into PyUnicode_Contains because its definition is unavailable 
PyUnicode_Contains
11235
                     "'in <string>' requires string as left operand, not %.100s",
11236
                     Py_TYPE(substr)->tp_name);
11237
        return -1;
11238
    }
11239
    if (PyUnicode_READY(substr) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Contains
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_Contains 
PyUnicode_Contains
11240
        return -1;
11241
    if (ensure_unicode(str) < 0)
inline
        
ensure_unicode can be inlined into PyUnicode_Contains with cost=95 (threshold=250) 
PyUnicode_Contains
inline
        
ensure_unicode inlined into PyUnicode_Contains 
PyUnicode_Contains
11242
        return -1;
11243
11244
    kind1 = PyUnicode_KIND(str);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Contains
gvn
            
load eliminated by PRE 
PyUnicode_Contains
11245
    kind2 = PyUnicode_KIND(substr);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Contains
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Contains
11246
    if (kind1 < kind2)
11247
        return 0;
11248
    len1 = PyUnicode_GET_LENGTH(str);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Contains
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Contains
11249
    len2 = PyUnicode_GET_LENGTH(substr);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Contains
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Contains
11250
    if (len1 < len2)
11251
        return 0;
11252
    buf1 = PyUnicode_DATA(str);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Contains
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Contains
11253
    buf2 = PyUnicode_DATA(substr);
gvn
           
load of type i32 eliminated in favor of load 
PyUnicode_Contains
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Contains
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Contains
11254
    if (len2 == 1) {
11255
        Py_UCS4 ch = PyUnicode_READ(kind2, buf2, 0);
11256
        result = findchar((const char *)buf1, kind1, len1, ch, 1) != -1;
inline
                 
findchar can be inlined into PyUnicode_Contains with cost=130 (threshold=325) 
PyUnicode_Contains
inline
                 
findchar inlined into PyUnicode_Contains 
PyUnicode_Contains
11257
        return result;
11258
    }
11259
    if (kind2 != kind1) {
11260
        buf2 = _PyUnicode_AsKind(substr, kind1);
inline
               
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
PyUnicode_Contains
inline
               
_PyUnicode_AsKind will not be inlined into PyUnicode_Contains 
PyUnicode_Contains
11261
        if (!buf2)
11262
            return -1;
11263
    }
11264
11265
    switch (kind1) {
11266
    case PyUnicode_1BYTE_KIND:
11267
        result = ucs1lib_find(buf1, len1, buf2, len2, 0) != -1;
inline
                 
ucs1lib_find can be inlined into PyUnicode_Contains with cost=30 (threshold=325) 
PyUnicode_Contains
inline
                 
ucs1lib_find inlined into PyUnicode_Contains 
PyUnicode_Contains
11268
        break;
11269
    case PyUnicode_2BYTE_KIND:
11270
        result = ucs2lib_find(buf1, len1, buf2, len2, 0) != -1;
inline
                 
ucs2lib_find can be inlined into PyUnicode_Contains with cost=30 (threshold=325) 
PyUnicode_Contains
inline
                 
ucs2lib_find inlined into PyUnicode_Contains 
PyUnicode_Contains
11271
        break;
11272
    case PyUnicode_4BYTE_KIND:
11273
        result = ucs4lib_find(buf1, len1, buf2, len2, 0) != -1;
inline
                 
ucs4lib_find can be inlined into PyUnicode_Contains with cost=30 (threshold=325) 
PyUnicode_Contains
inline
                 
ucs4lib_find inlined into PyUnicode_Contains 
PyUnicode_Contains
11274
        break;
11275
    default:
11276
        result = -1;
11277
        assert(0);
11278
    }
11279
11280
    if (kind2 != kind1)
11281
        PyMem_Free(buf2);
inline
        
PyMem_Free will not be inlined into PyUnicode_Contains because its definition is unavailable 
PyUnicode_Contains
11282
11283
    return result;
11284
}
11285
11286
/* Concat to string or Unicode object giving a new Unicode object. */
11287
11288
PyObject *
11289
PyUnicode_Concat(PyObject *left, PyObject *right)
11290
{
11291
    PyObject *result;
11292
    Py_UCS4 maxchar, maxchar2;
11293
    Py_ssize_t left_len, right_len, new_len;
11294
11295
    if (ensure_unicode(left) < 0 || ensure_unicode(right) < 0)
inline
        
ensure_unicode can be inlined into PyUnicode_Concat with cost=95 (threshold=250) 
PyUnicode_Concat
inline
        
ensure_unicode inlined into PyUnicode_Concat 
PyUnicode_Concat
inline
                                    
ensure_unicode can be inlined into PyUnicode_Concat with cost=95 (threshold=250) 
PyUnicode_Concat
inline
                                    
ensure_unicode inlined into PyUnicode_Concat 
PyUnicode_Concat
11296
        return NULL;
11297
11298
    /* Shortcuts */
11299
    if (left == unicode_empty)
gvn
                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Concat
11300
        return PyUnicode_FromObject(right);
inline
               
PyUnicode_FromObject can be inlined into PyUnicode_Concat with cost=165 (threshold=250) 
PyUnicode_Concat
inline
               
PyUnicode_FromObject inlined into PyUnicode_Concat 
PyUnicode_Concat
11301
    if (right == unicode_empty)
11302
        return PyUnicode_FromObject(left);
inline
               
PyUnicode_FromObject can be inlined into PyUnicode_Concat with cost=165 (threshold=250) 
PyUnicode_Concat
inline
               
PyUnicode_FromObject inlined into PyUnicode_Concat 
PyUnicode_Concat
11303
11304
    left_len = PyUnicode_GET_LENGTH(left);
gvn
               
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Concat
11305
    right_len = PyUnicode_GET_LENGTH(right);
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Concat
11306
    if (left_len > PY_SSIZE_T_MAX - right_len) {
11307
        PyErr_SetString(PyExc_OverflowError,
inline
        
PyErr_SetString will not be inlined into PyUnicode_Concat because its definition is unavailable 
PyUnicode_Concat
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Concat
11308
                        "strings are too large to concat");
11309
        return NULL;
11310
    }
11311
    new_len = left_len + right_len;
11312
11313
    maxchar = PyUnicode_MAX_CHAR_VALUE(left);
gvn
              
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Concat
11314
    maxchar2 = PyUnicode_MAX_CHAR_VALUE(right);
gvn
               
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Concat
11315
    maxchar = Py_MAX(maxchar, maxchar2);
11316
11317
    /* Concat the two Unicode strings */
11318
    result = PyUnicode_New(new_len, maxchar);
inline
             
PyUnicode_New too costly to inline (cost=460, threshold=250) 
PyUnicode_Concat
inline
             
PyUnicode_New will not be inlined into PyUnicode_Concat 
PyUnicode_Concat
11319
    if (result == NULL)
11320
        return NULL;
11321
    _PyUnicode_FastCopyCharacters(result, 0, left, 0, left_len);
inline
    
_PyUnicode_FastCopyCharacters can be inlined into PyUnicode_Concat with cost=5 (threshold=375) 
PyUnicode_Concat
inline
    
_PyUnicode_FastCopyCharacters inlined into PyUnicode_Concat 
PyUnicode_Concat
11322
    _PyUnicode_FastCopyCharacters(result, left_len, right, 0, right_len);
inline
    
_PyUnicode_FastCopyCharacters can be inlined into PyUnicode_Concat with cost=5 (threshold=375) 
PyUnicode_Concat
inline
    
_PyUnicode_FastCopyCharacters inlined into PyUnicode_Concat 
PyUnicode_Concat
11323
    assert(_PyUnicode_CheckConsistency(result, 1));
11324
    return result;
11325
}
11326
11327
void
11328
PyUnicode_Append(PyObject **p_left, PyObject *right)
11329
{
11330
    PyObject *left, *res;
11331
    Py_UCS4 maxchar, maxchar2;
11332
    Py_ssize_t left_len, right_len, new_len;
11333
11334
    if (p_left == NULL) {
11335
        if (!PyErr_Occurred())
inline
             
PyErr_Occurred will not be inlined into PyUnicode_Append because its definition is unavailable 
PyUnicode_Append
11336
            PyErr_BadInternalCall();
inline
            
_PyErr_BadInternalCall will not be inlined into PyUnicode_Append because its definition is unavailable 
PyUnicode_Append
11337
        return;
11338
    }
11339
    left = *p_left;
11340
    if (right == NULL || left == NULL
11341
        || !PyUnicode_Check(left) || !PyUnicode_Check(right)) {
11342
        if (!PyErr_Occurred())
inline
             
PyErr_Occurred will not be inlined into PyUnicode_Append because its definition is unavailable 
PyUnicode_Append
11343
            PyErr_BadInternalCall();
inline
            
_PyErr_BadInternalCall will not be inlined into PyUnicode_Append because its definition is unavailable 
PyUnicode_Append
11344
        goto error;
11345
    }
11346
11347
    if (PyUnicode_READY(left) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Append
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_Append 
PyUnicode_Append
11348
        goto error;
11349
    if (PyUnicode_READY(right) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Append
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_Append 
PyUnicode_Append
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Append
11350
        goto error;
11351
11352
    /* Shortcuts */
11353
    if (left == unicode_empty) {
gvn
                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Append
gvn
                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Append
11354
        Py_DECREF(left);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Append
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Append
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
11355
        Py_INCREF(right);
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Append
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Append
11356
        *p_left = right;
11357
        return;
11358
    }
11359
    if (right == unicode_empty)
11360
        return;
11361
11362
    left_len = PyUnicode_GET_LENGTH(left);
gvn
               
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Append
gvn
               
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Append
11363
    right_len = PyUnicode_GET_LENGTH(right);
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Append
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Append
11364
    if (left_len > PY_SSIZE_T_MAX - right_len) {
11365
        PyErr_SetString(PyExc_OverflowError,
inline
        
PyErr_SetString will not be inlined into PyUnicode_Append because its definition is unavailable 
PyUnicode_Append
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Append
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Append
11366
                        "strings are too large to concat");
11367
        goto error;
11368
    }
11369
    new_len = left_len + right_len;
11370
11371
    if (unicode_modifiable(left)
inline
        
unicode_modifiable can be inlined into PyUnicode_Append with cost=-14975 (threshold=250) 
PyUnicode_Append
inline
        
unicode_modifiable inlined into PyUnicode_Append 
PyUnicode_Append
11372
        && PyUnicode_CheckExact(right)
gvn
           
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
           
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
11373
        && PyUnicode_KIND(right) <= PyUnicode_KIND(left)
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
                                    
load of type i32 eliminated in favor of load 
PyUnicode_Append
11374
        /* Don't resize for ascii += latin1. Convert ascii to latin1 requires
11375
           to change the structure size, but characters are stored just after
11376
           the structure, and so it requires to move all characters which is
11377
           not so different than duplicating the string. */
11378
        && !(PyUnicode_IS_ASCII(left) && !PyUnicode_IS_ASCII(right)))
11379
    {
11380
        /* append inplace */
11381
        if (unicode_resize(p_left, new_len) != 0)
inline
            
unicode_resize too costly to inline (cost=630, threshold=625) 
PyUnicode_Append
inline
            
unicode_resize will not be inlined into PyUnicode_Append 
PyUnicode_Append
11382
            goto error;
11383
11384
        /* copy 'right' into the newly allocated area of 'left' */
11385
        _PyUnicode_FastCopyCharacters(*p_left, left_len, right, 0, right_len);
inline
        
_PyUnicode_FastCopyCharacters can be inlined into PyUnicode_Append with cost=5 (threshold=375) 
PyUnicode_Append
inline
        
_PyUnicode_FastCopyCharacters inlined into PyUnicode_Append 
PyUnicode_Append
gvn
                                      
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
11386
    }
11387
    else {
11388
        maxchar = PyUnicode_MAX_CHAR_VALUE(left);
gvn
                  
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
                  
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
11389
        maxchar2 = PyUnicode_MAX_CHAR_VALUE(right);
gvn
                   
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
11390
        maxchar = Py_MAX(maxchar, maxchar2);
11391
11392
        /* Concat the two Unicode strings */
11393
        res = PyUnicode_New(new_len, maxchar);
inline
              
PyUnicode_New too costly to inline (cost=460, threshold=250) 
PyUnicode_Append
inline
              
PyUnicode_New will not be inlined into PyUnicode_Append 
PyUnicode_Append
11394
        if (res == NULL)
11395
            goto error;
11396
        _PyUnicode_FastCopyCharacters(res, 0, left, 0, left_len);
inline
        
_PyUnicode_FastCopyCharacters can be inlined into PyUnicode_Append with cost=5 (threshold=375) 
PyUnicode_Append
inline
        
_PyUnicode_FastCopyCharacters inlined into PyUnicode_Append 
PyUnicode_Append
11397
        _PyUnicode_FastCopyCharacters(res, left_len, right, 0, right_len);
inline
        
_PyUnicode_FastCopyCharacters can be inlined into PyUnicode_Append with cost=5 (threshold=375) 
PyUnicode_Append
inline
        
_PyUnicode_FastCopyCharacters inlined into PyUnicode_Append 
PyUnicode_Append
11398
        Py_DECREF(left);
gvn
        
load of type i64 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
11399
        *p_left = res;
11400
    }
11401
    assert(_PyUnicode_CheckConsistency(*p_left, 1));
11402
    return;
11403
11404
error:
11405
    Py_CLEAR(*p_left);
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Append
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by store 
PyUnicode_Append
11406
}
11407
11408
void
11409
PyUnicode_AppendAndDel(PyObject **pleft, PyObject *right)
11410
{
11411
    PyUnicode_Append(pleft, right);
inline
    
PyUnicode_Append too costly to inline (cost=630, threshold=625) 
PyUnicode_AppendAndDel
inline
    
PyUnicode_Append will not be inlined into PyUnicode_AppendAndDel 
PyUnicode_AppendAndDel
11412
    Py_XDECREF(right);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AppendAndDel
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_AppendAndDel
11413
}
11414
11415
/*
11416
Wraps stringlib_parse_args_finds() and additionally ensures that the
11417
first argument is a unicode object.
11418
*/
11419
11420
static inline int
11421
parse_args_finds_unicode(const char * function_name, PyObject *args,
11422
                         PyObject **substring,
11423
                         Py_ssize_t *start, Py_ssize_t *end)
11424
{
11425
    if(stringlib_parse_args_finds(function_name, args, substring,
inline
       
stringlib_parse_args_finds too costly to inline (cost=345, threshold=325) 
parse_args_finds_unicode
inline
       
stringlib_parse_args_finds will not be inlined into parse_args_finds_unicode 
parse_args_finds_unicode
inline
       
stringlib_parse_args_finds too costly to inline (cost=330, threshold=325) 
unicode_count
inline
       
stringlib_parse_args_finds will not be inlined into unicode_count 
unicode_count
inline
       
stringlib_parse_args_finds too costly to inline (cost=330, threshold=325) 
unicode_find
inline
       
stringlib_parse_args_finds will not be inlined into unicode_find 
unicode_find
inline
       
stringlib_parse_args_finds too costly to inline (cost=330, threshold=325) 
unicode_index
inline
       
stringlib_parse_args_finds will not be inlined into unicode_index 
unicode_index
inline
       
stringlib_parse_args_finds too costly to inline (cost=330, threshold=325) 
unicode_rfind
inline
       
stringlib_parse_args_finds will not be inlined into unicode_rfind 
unicode_rfind
inline
       
stringlib_parse_args_finds too costly to inline (cost=330, threshold=325) 
unicode_rindex
inline
       
stringlib_parse_args_finds will not be inlined into unicode_rindex 
unicode_rindex
11426
                                  start, end)) {
11427
        if (ensure_unicode(*substring) < 0)
inline
            
ensure_unicode can be inlined into parse_args_finds_unicode with cost=-14905 (threshold=250) 
parse_args_finds_unicode
inline
            
ensure_unicode inlined into parse_args_finds_unicode 
parse_args_finds_unicode
gvn
                           
load of type %struct._object* not eliminated because it is clobbered by call 
parse_args_finds_unicode
gvn
                           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_count
gvn
                           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_find
gvn
                           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_index
gvn
                           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_rfind
gvn
                           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_rindex
11428
            return 0;
11429
        return 1;
11430
    }
11431
    return 0;
11432
}
11433
11434
PyDoc_STRVAR(count__doc__,
11435
             "S.count(sub[, start[, end]]) -> int\n\
11436
\n\
11437
Return the number of non-overlapping occurrences of substring sub in\n\
11438
string S[start:end].  Optional arguments start and end are\n\
11439
interpreted as in slice notation.");
11440
11441
static PyObject *
11442
unicode_count(PyObject *self, PyObject *args)
11443
{
11444
    PyObject *substring = NULL;   /* initialize to fix a compiler warning */
11445
    Py_ssize_t start = 0;
11446
    Py_ssize_t end = PY_SSIZE_T_MAX;
11447
    PyObject *result;
11448
    int kind1, kind2;
11449
    void *buf1, *buf2;
11450
    Py_ssize_t len1, len2, iresult;
11451
11452
    if (!parse_args_finds_unicode("count", args, &substring, &start, &end))
inline
         
parse_args_finds_unicode can be inlined into unicode_count with cost=155 (threshold=325) 
unicode_count
inline
         
parse_args_finds_unicode inlined into unicode_count 
unicode_count
11453
        return NULL;
11454
11455
    kind1 = PyUnicode_KIND(self);
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_count
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_count
11456
    kind2 = PyUnicode_KIND(substring);
gvn
            
load of type %struct.PyASCIIObject* eliminated in favor of inttoptr 
unicode_count
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_count
11457
    if (kind1 < kind2)
11458
        return PyLong_FromLong(0);
inline
               
PyLong_FromLong will not be inlined into unicode_count because its definition is unavailable 
unicode_count
11459
11460
    len1 = PyUnicode_GET_LENGTH(self);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
unicode_count
gvn
           
load of type i64 not eliminated because it is clobbered by call 
unicode_count
11461
    len2 = PyUnicode_GET_LENGTH(substring);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
unicode_count
11462
    ADJUST_INDICES(start, end, len1);
gvn
    
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_count
gvn
    
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_count
11463
    if (end - start < len2)
gvn
        
load of type i64 eliminated in favor of phi 
unicode_count
gvn
              
load of type i64 eliminated in favor of phi 
unicode_count
11464
        return PyLong_FromLong(0);
inline
               
PyLong_FromLong will not be inlined into unicode_count because its definition is unavailable 
unicode_count
11465
11466
    buf1 = PyUnicode_DATA(self);
gvn
           
load of type i32 eliminated in favor of load 
unicode_count
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_count
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_count
11467
    buf2 = PyUnicode_DATA(substring);
gvn
           
load of type %struct._object* eliminated in favor of load 
unicode_count
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_count
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_count
11468
    if (kind2 != kind1) {
11469
        buf2 = _PyUnicode_AsKind(substring, kind1);
inline
               
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
unicode_count
inline
               
_PyUnicode_AsKind will not be inlined into unicode_count 
unicode_count
11470
        if (!buf2)
11471
            return NULL;
11472
    }
11473
    switch (kind1) {
11474
    case PyUnicode_1BYTE_KIND:
11475
        iresult = ucs1lib_count(
inline
                  
ucs1lib_count can be inlined into unicode_count with cost=-14950 (threshold=325) 
unicode_count
inline
                  
ucs1lib_count inlined into unicode_count 
unicode_count
11476
            ((Py_UCS1*)buf1) + start, end - start,
gvn
                               
load of type i64 eliminated in favor of phi 
unicode_count
gvn
                                      
load of type i64 eliminated in favor of phi 
unicode_count
11477
            buf2, len2, PY_SSIZE_T_MAX
11478
            );
11479
        break;
11480
    case PyUnicode_2BYTE_KIND:
11481
        iresult = ucs2lib_count(
inline
                  
ucs2lib_count can be inlined into unicode_count with cost=-14950 (threshold=325) 
unicode_count
inline
                  
ucs2lib_count inlined into unicode_count 
unicode_count
11482
            ((Py_UCS2*)buf1) + start, end - start,
gvn
                               
load of type i64 eliminated in favor of phi 
unicode_count
gvn
                                      
load of type i64 eliminated in favor of phi 
unicode_count
11483
            buf2, len2, PY_SSIZE_T_MAX
11484
            );
11485
        break;
11486
    case PyUnicode_4BYTE_KIND:
11487
        iresult = ucs4lib_count(
inline
                  
ucs4lib_count can be inlined into unicode_count with cost=-14950 (threshold=325) 
unicode_count
inline
                  
ucs4lib_count inlined into unicode_count 
unicode_count
11488
            ((Py_UCS4*)buf1) + start, end - start,
gvn
                               
load of type i64 eliminated in favor of phi 
unicode_count
gvn
                                      
load of type i64 eliminated in favor of phi 
unicode_count
11489
            buf2, len2, PY_SSIZE_T_MAX
11490
            );
11491
        break;
11492
    default:
11493
        assert(0); iresult = 0;
11494
    }
11495
11496
    result = PyLong_FromSsize_t(iresult);
inline
             
PyLong_FromSsize_t will not be inlined into unicode_count because its definition is unavailable 
unicode_count
11497
11498
    if (kind2 != kind1)
11499
        PyMem_Free(buf2);
inline
        
PyMem_Free will not be inlined into unicode_count because its definition is unavailable 
unicode_count
11500
11501
    return result;
11502
}
11503
11504
PyDoc_STRVAR(encode__doc__,
11505
             "S.encode(encoding='utf-8', errors='strict') -> bytes\n\
11506
\n\
11507
Encode S using the codec registered for encoding. Default encoding\n\
11508
is 'utf-8'. errors may be given to set a different error\n\
11509
handling scheme. Default is 'strict' meaning that encoding errors raise\n\
11510
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n\
11511
'xmlcharrefreplace' as well as any other name registered with\n\
11512
codecs.register_error that can handle UnicodeEncodeErrors.");
11513
11514
static PyObject *
11515
unicode_encode(PyObject *self, PyObject *args, PyObject *kwargs)
11516
{
11517
    static char *kwlist[] = {"encoding", "errors", 0};
11518
    char *encoding = NULL;
11519
    char *errors = NULL;
11520
11521
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ss:encode",
inline
         
_PyArg_ParseTupleAndKeywords_SizeT will not be inlined into unicode_encode because its definition is unavailable 
unicode_encode
11522
                                     kwlist, &encoding, &errors))
11523
        return NULL;
11524
    return PyUnicode_AsEncodedString(self, encoding, errors);
inline
           
PyUnicode_AsEncodedString too costly to inline (cost=655, threshold=625) 
unicode_encode
inline
           
PyUnicode_AsEncodedString will not be inlined into unicode_encode 
unicode_encode
gvn
                                           
load of type i8* not eliminated in favor of store because it is clobbered by call 
unicode_encode
gvn
                                                     
load of type i8* not eliminated in favor of store because it is clobbered by call 
unicode_encode
11525
}
11526
11527
PyDoc_STRVAR(expandtabs__doc__,
11528
             "S.expandtabs(tabsize=8) -> str\n\
11529
\n\
11530
Return a copy of S where all tab characters are expanded using spaces.\n\
11531
If tabsize is not given, a tab size of 8 characters is assumed.");
11532
11533
static PyObject*
11534
unicode_expandtabs(PyObject *self, PyObject *args, PyObject *kwds)
11535
{
11536
    Py_ssize_t i, j, line_pos, src_len, incr;
11537
    Py_UCS4 ch;
11538
    PyObject *u;
11539
    void *src_data, *dest_data;
11540
    static char *kwlist[] = {"tabsize", 0};
11541
    int tabsize = 8;
11542
    int kind;
11543
    int found;
11544
11545
    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|i:expandtabs",
inline
         
_PyArg_ParseTupleAndKeywords_SizeT will not be inlined into unicode_expandtabs because its definition is unavailable 
unicode_expandtabs
11546
                                     kwlist, &tabsize))
11547
        return NULL;
11548
11549
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_expandtabs
inline
        
_PyUnicode_Ready will not be inlined into unicode_expandtabs 
unicode_expandtabs
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_expandtabs
11550
        return NULL;
11551
11552
    /* First pass: determine size of output string */
11553
    src_len = PyUnicode_GET_LENGTH(self);
gvn
              
load of type i64 not eliminated because it is clobbered by call 
unicode_expandtabs
gvn
              
load of type i64 not eliminated because it is clobbered by call 
unicode_expandtabs
11554
    i = j = line_pos = 0;
11555
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_expandtabs
gvn
           
load eliminated by PRE 
unicode_expandtabs
11556
    src_data = PyUnicode_DATA(self);
gvn
               
load of type i8* not eliminated because it is clobbered by call 
unicode_expandtabs
gvn
               
load of type i8* not eliminated because it is clobbered by call 
unicode_expandtabs
11557
    found = 0;
11558
    for (; i < src_len; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_expandtabs
loop-vectorize
    
loop not vectorized 
unicode_expandtabs
11559
        ch = PyUnicode_READ(kind, src_data, i);
licm
             
hosting trunc 
unicode_expandtabs
licm
             
hosting bitcast 
unicode_expandtabs
11560
        if (ch == '\t') {
11561
            found = 1;
11562
            if (tabsize > 0) {
licm
                
hosting load 
unicode_expandtabs
licm
                        
hosting icmp 
unicode_expandtabs
11563
                incr = tabsize - (line_pos % tabsize); /* cannot overflow */
licm
                       
hosting sext 
unicode_expandtabs
11564
                if (j > PY_SSIZE_T_MAX - incr)
11565
                    goto overflow;
11566
                line_pos += incr;
11567
                j += incr;
11568
            }
11569
        }
11570
        else {
11571
            if (j > PY_SSIZE_T_MAX - 1)
11572
                goto overflow;
11573
            line_pos++;
11574
            j++;
11575
            if (ch == '\n' || ch == '\r')
11576
                line_pos = 0;
11577
        }
11578
    }
11579
    if (!found)
11580
        return unicode_result_unchanged(self);
inline
               
unicode_result_unchanged can be inlined into unicode_expandtabs with cost=90 (threshold=250) 
unicode_expandtabs
inline
               
unicode_result_unchanged inlined into unicode_expandtabs 
unicode_expandtabs
11581
11582
    /* Second pass: create output string and fill it */
11583
    u = PyUnicode_New(j, PyUnicode_MAX_CHAR_VALUE(self));
inline
        
PyUnicode_New too costly to inline (cost=460, threshold=250) 
unicode_expandtabs
inline
        
PyUnicode_New will not be inlined into unicode_expandtabs 
unicode_expandtabs
gvn
                         
load of type i32 eliminated in favor of phi 
unicode_expandtabs
11584
    if (!u)
11585
        return NULL;
11586
    dest_data = PyUnicode_DATA(u);
gvn
                
load of type i32 not eliminated because it is clobbered by call 
unicode_expandtabs
gvn
                
load of type i8* not eliminated because it is clobbered by call 
unicode_expandtabs
11587
11588
    i = j = line_pos = 0;
11589
11590
    for (; i < src_len; i++) {
loop-vectorize
    
loop not vectorized 
unicode_expandtabs
11591
        ch = PyUnicode_READ(kind, src_data, i);
licm
             
hosting trunc 
unicode_expandtabs
licm
             
hosting bitcast 
unicode_expandtabs
gvn
             
load of type i32 not eliminated because it is clobbered by call 
unicode_expandtabs
gvn
             
load of type i16 not eliminated because it is clobbered by call 
unicode_expandtabs
gvn
             
load of type i8 not eliminated because it is clobbered by call 
unicode_expandtabs
licm
             
hosting icmp 
unicode_expandtabs
11592
        if (ch == '\t') {
11593
            if (tabsize > 0) {
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_expandtabs
gvn
                
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_expandtabs
gvn
                
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_expandtabs
gvn
                
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_expandtabs
gvn
                
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_expandtabs
11594
                incr = tabsize - (line_pos % tabsize);
11595
                line_pos += incr;
11596
                FILL(kind, dest_data, ' ', j, incr);
licm
                
hosting trunc 
unicode_expandtabs
licm
                
hosting bitcast 
unicode_expandtabs
loop-vectorize
                
vectorized loop (vectorization width: 8, interleaved count: 2) 
unicode_expandtabs
loop-vectorize
                
vectorized loop (vectorization width: 4, interleaved count: 2) 
unicode_expandtabs
loop-unroll
                
unrolled loop by a factor of 8 with run-time trip count 
unicode_expandtabs
11597
                j += incr;
11598
            }
11599
        }
11600
        else {
11601
            line_pos++;
11602
            PyUnicode_WRITE(kind, dest_data, j, ch);
licm
            
hosting trunc 
unicode_expandtabs
licm
            
hosting bitcast 
unicode_expandtabs
11603
            j++;
11604
            if (ch == '\n' || ch == '\r')
loop-vectorize
                           
loop not vectorized: loop contains a switch statement 
unicode_expandtabs
11605
                line_pos = 0;
11606
        }
11607
    }
11608
    assert (j == PyUnicode_GET_LENGTH(u));
11609
    return unicode_result(u);
inline
           
unicode_result too costly to inline (cost=460, threshold=250) 
unicode_expandtabs
inline
           
unicode_result will not be inlined into unicode_expandtabs 
unicode_expandtabs
11610
11611
  overflow:
11612
    PyErr_SetString(PyExc_OverflowError, "new string is too long");
inline
    
PyErr_SetString will not be inlined into unicode_expandtabs because its definition is unavailable 
unicode_expandtabs
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_expandtabs
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_expandtabs
11613
    return NULL;
11614
}
11615
11616
PyDoc_STRVAR(find__doc__,
11617
             "S.find(sub[, start[, end]]) -> int\n\
11618
\n\
11619
Return the lowest index in S where substring sub is found,\n\
11620
such that sub is contained within S[start:end].  Optional\n\
11621
arguments start and end are interpreted as in slice notation.\n\
11622
\n\
11623
Return -1 on failure.");
11624
11625
static PyObject *
11626
unicode_find(PyObject *self, PyObject *args)
11627
{
11628
    /* initialize variables to prevent gcc warning */
11629
    PyObject *substring = NULL;
11630
    Py_ssize_t start = 0;
11631
    Py_ssize_t end = 0;
11632
    Py_ssize_t result;
11633
11634
    if (!parse_args_finds_unicode("find", args, &substring, &start, &end))
inline
         
parse_args_finds_unicode can be inlined into unicode_find with cost=155 (threshold=325) 
unicode_find
inline
         
parse_args_finds_unicode inlined into unicode_find 
unicode_find
11635
        return NULL;
11636
11637
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_find
inline
        
_PyUnicode_Ready will not be inlined into unicode_find 
unicode_find
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_find
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_find
11638
        return NULL;
11639
11640
    result = any_find_slice(self, substring, start, end, 1);
inline
             
any_find_slice too costly to inline (cost=630, threshold=625) 
unicode_find
inline
             
any_find_slice will not be inlined into unicode_find 
unicode_find
gvn
                                  
load of type %struct._object* eliminated in favor of load 
unicode_find
gvn
                                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_find
gvn
                                                    
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_find
11641
11642
    if (result == -2)
11643
        return NULL;
11644
11645
    return PyLong_FromSsize_t(result);
inline
           
PyLong_FromSsize_t will not be inlined into unicode_find because its definition is unavailable 
unicode_find
11646
}
11647
11648
static PyObject *
11649
unicode_getitem(PyObject *self, Py_ssize_t index)
11650
{
11651
    void *data;
11652
    enum PyUnicode_Kind kind;
11653
    Py_UCS4 ch;
11654
11655
    if (!PyUnicode_Check(self) || PyUnicode_READY(self) == -1) {
inline
                                  
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_getitem
inline
                                  
_PyUnicode_Ready will not be inlined into unicode_getitem 
unicode_getitem
11656
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into unicode_getitem because its definition is unavailable 
unicode_getitem
11657
        return NULL;
11658
    }
11659
    if (index < 0 || index >= PyUnicode_GET_LENGTH(self)) {
gvn
                              
load of type i64 not eliminated because it is clobbered by call 
unicode_getitem
11660
        PyErr_SetString(PyExc_IndexError, "string index out of range");
inline
        
PyErr_SetString will not be inlined into unicode_getitem because its definition is unavailable 
unicode_getitem
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_getitem
11661
        return NULL;
11662
    }
11663
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_getitem
11664
    data = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_getitem
11665
    ch = PyUnicode_READ(kind, data, index);
11666
    return unicode_char(ch);
inline
           
unicode_char can be inlined into unicode_getitem with cost=-14795 (threshold=250) 
unicode_getitem
inline
           
unicode_char inlined into unicode_getitem 
unicode_getitem
11667
}
11668
11669
/* Believe it or not, this produces the same value for ASCII strings
11670
   as bytes_hash(). */
11671
static Py_hash_t
11672
unicode_hash(PyObject *self)
11673
{
11674
    Py_ssize_t len;
11675
    Py_uhash_t x;  /* Unsigned for defined overflow behavior. */
11676
11677
#ifdef Py_DEBUG
11678
    assert(_Py_HashSecret_Initialized);
11679
#endif
11680
    if (_PyUnicode_HASH(self) != -1)
11681
        return _PyUnicode_HASH(self);
11682
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_hash
inline
        
_PyUnicode_Ready will not be inlined into unicode_hash 
unicode_hash
11683
        return -1;
11684
    len = PyUnicode_GET_LENGTH(self);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
unicode_hash
11685
    /*
11686
      We make the hash of the empty string be 0, rather than using
11687
      (prefix ^ suffix), since this slightly obfuscates the hash secret
11688
    */
11689
    if (len == 0) {
11690
        _PyUnicode_HASH(self) = 0;
11691
        return 0;
11692
    }
11693
    x = _Py_HashBytes(PyUnicode_DATA(self),
inline
        
_Py_HashBytes will not be inlined into unicode_hash because its definition is unavailable 
unicode_hash
gvn
                      
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_hash
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
unicode_hash
11694
                      PyUnicode_GET_LENGTH(self) * PyUnicode_KIND(self));
11695
    _PyUnicode_HASH(self) = x;
11696
    return x;
11697
}
11698
11699
PyDoc_STRVAR(index__doc__,
11700
             "S.index(sub[, start[, end]]) -> int\n\
11701
\n\
11702
Like S.find() but raise ValueError when the substring is not found.");
11703
11704
static PyObject *
11705
unicode_index(PyObject *self, PyObject *args)
11706
{
11707
    /* initialize variables to prevent gcc warning */
11708
    Py_ssize_t result;
11709
    PyObject *substring = NULL;
11710
    Py_ssize_t start = 0;
11711
    Py_ssize_t end = 0;
11712
11713
    if (!parse_args_finds_unicode("index", args, &substring, &start, &end))
inline
         
parse_args_finds_unicode can be inlined into unicode_index with cost=155 (threshold=325) 
unicode_index
inline
         
parse_args_finds_unicode inlined into unicode_index 
unicode_index
11714
        return NULL;
11715
11716
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_index
inline
        
_PyUnicode_Ready will not be inlined into unicode_index 
unicode_index
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_index
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_index
11717
        return NULL;
11718
11719
    result = any_find_slice(self, substring, start, end, 1);
inline
             
any_find_slice too costly to inline (cost=630, threshold=625) 
unicode_index
inline
             
any_find_slice will not be inlined into unicode_index 
unicode_index
gvn
                                  
load of type %struct._object* eliminated in favor of load 
unicode_index
gvn
                                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_index
gvn
                                                    
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_index
11720
11721
    if (result == -2)
11722
        return NULL;
11723
11724
    if (result < 0) {
11725
        PyErr_SetString(PyExc_ValueError, "substring not found");
inline
        
PyErr_SetString will not be inlined into unicode_index because its definition is unavailable 
unicode_index
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_index
11726
        return NULL;
11727
    }
11728
11729
    return PyLong_FromSsize_t(result);
inline
           
PyLong_FromSsize_t will not be inlined into unicode_index because its definition is unavailable 
unicode_index
11730
}
11731
11732
PyDoc_STRVAR(islower__doc__,
11733
             "S.islower() -> bool\n\
11734
\n\
11735
Return True if all cased characters in S are lowercase and there is\n\
11736
at least one cased character in S, False otherwise.");
11737
11738
static PyObject*
11739
unicode_islower(PyObject *self)
11740
{
11741
    Py_ssize_t i, length;
11742
    int kind;
11743
    void *data;
11744
    int cased;
11745
11746
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_islower
inline
        
_PyUnicode_Ready will not be inlined into unicode_islower 
unicode_islower
11747
        return NULL;
11748
    length = PyUnicode_GET_LENGTH(self);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_islower
11749
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_islower
gvn
           
load eliminated by PRE 
unicode_islower
11750
    data = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_islower
11751
11752
    /* Shortcut for single character strings */
11753
    if (length == 1)
11754
        return PyBool_FromLong(
inline
               
PyBool_FromLong will not be inlined into unicode_islower because its definition is unavailable 
unicode_islower
11755
            Py_UNICODE_ISLOWER(PyUnicode_READ(kind, data, 0)));
inline
            
_PyUnicode_IsLowercase will not be inlined into unicode_islower because its definition is unavailable 
unicode_islower
11756
11757
    /* Special case for empty strings */
11758
    if (length == 0)
11759
        return PyBool_FromLong(0);
inline
               
PyBool_FromLong will not be inlined into unicode_islower because its definition is unavailable 
unicode_islower
11760
11761
    cased = 0;
11762
    for (i = 0; i < length; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_islower
loop-vectorize
    
loop not vectorized 
unicode_islower
11763
        const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
licm
                           
hosting trunc 
unicode_islower
licm
                           
hosting bitcast 
unicode_islower
11764
11765
        if (Py_UNICODE_ISUPPER(ch) || Py_UNICODE_ISTITLE(ch))
inline
            
_PyUnicode_IsUppercase will not be inlined into unicode_islower because its definition is unavailable 
unicode_islower
inline
                                      
_PyUnicode_IsTitlecase will not be inlined into unicode_islower because its definition is unavailable 
unicode_islower
11766
            return PyBool_FromLong(0);
inline
                   
PyBool_FromLong will not be inlined into unicode_islower because its definition is unavailable 
unicode_islower
11767
        else if (!cased && Py_UNICODE_ISLOWER(ch))
inline
                           
_PyUnicode_IsLowercase will not be inlined into unicode_islower because its definition is unavailable 
unicode_islower
11768
            cased = 1;
11769
    }
11770
    return PyBool_FromLong(cased);
inline
           
PyBool_FromLong will not be inlined into unicode_islower because its definition is unavailable 
unicode_islower
11771
}
11772
11773
PyDoc_STRVAR(isupper__doc__,
11774
             "S.isupper() -> bool\n\
11775
\n\
11776
Return True if all cased characters in S are uppercase and there is\n\
11777
at least one cased character in S, False otherwise.");
11778
11779
static PyObject*
11780
unicode_isupper(PyObject *self)
11781
{
11782
    Py_ssize_t i, length;
11783
    int kind;
11784
    void *data;
11785
    int cased;
11786
11787
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_isupper
inline
        
_PyUnicode_Ready will not be inlined into unicode_isupper 
unicode_isupper
11788
        return NULL;
11789
    length = PyUnicode_GET_LENGTH(self);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_isupper
11790
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_isupper
gvn
           
load eliminated by PRE 
unicode_isupper
11791
    data = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_isupper
11792
11793
    /* Shortcut for single character strings */
11794
    if (length == 1)
11795
        return PyBool_FromLong(
inline
               
PyBool_FromLong will not be inlined into unicode_isupper because its definition is unavailable 
unicode_isupper
11796
            Py_UNICODE_ISUPPER(PyUnicode_READ(kind, data, 0)) != 0);
inline
            
_PyUnicode_IsUppercase will not be inlined into unicode_isupper because its definition is unavailable 
unicode_isupper
11797
11798
    /* Special case for empty strings */
11799
    if (length == 0)
11800
        return PyBool_FromLong(0);
inline
               
PyBool_FromLong will not be inlined into unicode_isupper because its definition is unavailable 
unicode_isupper
11801
11802
    cased = 0;
11803
    for (i = 0; i < length; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_isupper
loop-vectorize
    
loop not vectorized 
unicode_isupper
11804
        const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
licm
                           
hosting trunc 
unicode_isupper
licm
                           
hosting bitcast 
unicode_isupper
11805
11806
        if (Py_UNICODE_ISLOWER(ch) || Py_UNICODE_ISTITLE(ch))
inline
            
_PyUnicode_IsLowercase will not be inlined into unicode_isupper because its definition is unavailable 
unicode_isupper
inline
                                      
_PyUnicode_IsTitlecase will not be inlined into unicode_isupper because its definition is unavailable 
unicode_isupper
11807
            return PyBool_FromLong(0);
inline
                   
PyBool_FromLong will not be inlined into unicode_isupper because its definition is unavailable 
unicode_isupper
11808
        else if (!cased && Py_UNICODE_ISUPPER(ch))
inline
                           
_PyUnicode_IsUppercase will not be inlined into unicode_isupper because its definition is unavailable 
unicode_isupper
11809
            cased = 1;
11810
    }
11811
    return PyBool_FromLong(cased);
inline
           
PyBool_FromLong will not be inlined into unicode_isupper because its definition is unavailable 
unicode_isupper
11812
}
11813
11814
PyDoc_STRVAR(istitle__doc__,
11815
             "S.istitle() -> bool\n\
11816
\n\
11817
Return True if S is a titlecased string and there is at least one\n\
11818
character in S, i.e. upper- and titlecase characters may only\n\
11819
follow uncased characters and lowercase characters only cased ones.\n\
11820
Return False otherwise.");
11821
11822
static PyObject*
11823
unicode_istitle(PyObject *self)
11824
{
11825
    Py_ssize_t i, length;
11826
    int kind;
11827
    void *data;
11828
    int cased, previous_is_cased;
11829
11830
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_istitle
inline
        
_PyUnicode_Ready will not be inlined into unicode_istitle 
unicode_istitle
11831
        return NULL;
11832
    length = PyUnicode_GET_LENGTH(self);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_istitle
11833
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_istitle
gvn
           
load eliminated by PRE 
unicode_istitle
11834
    data = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_istitle
11835
11836
    /* Shortcut for single character strings */
11837
    if (length == 1) {
11838
        Py_UCS4 ch = PyUnicode_READ(kind, data, 0);
11839
        return PyBool_FromLong((Py_UNICODE_ISTITLE(ch) != 0) ||
inline
                                
_PyUnicode_IsTitlecase will not be inlined into unicode_istitle because its definition is unavailable 
unicode_istitle
inline
               
PyBool_FromLong will not be inlined into unicode_istitle because its definition is unavailable 
unicode_istitle
11840
                               (Py_UNICODE_ISUPPER(ch) != 0));
inline
                                
_PyUnicode_IsUppercase will not be inlined into unicode_istitle because its definition is unavailable 
unicode_istitle
11841
    }
11842
11843
    /* Special case for empty strings */
11844
    if (length == 0)
11845
        return PyBool_FromLong(0);
inline
               
PyBool_FromLong will not be inlined into unicode_istitle because its definition is unavailable 
unicode_istitle
11846
11847
    cased = 0;
11848
    previous_is_cased = 0;
11849
    for (i = 0; i < length; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_istitle
loop-vectorize
    
loop not vectorized 
unicode_istitle
11850
        const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
licm
                           
hosting trunc 
unicode_istitle
licm
                           
hosting bitcast 
unicode_istitle
11851
11852
        if (Py_UNICODE_ISUPPER(ch) || Py_UNICODE_ISTITLE(ch)) {
inline
            
_PyUnicode_IsUppercase will not be inlined into unicode_istitle because its definition is unavailable 
unicode_istitle
inline
                                      
_PyUnicode_IsTitlecase will not be inlined into unicode_istitle because its definition is unavailable 
unicode_istitle
11853
            if (previous_is_cased)
11854
                return PyBool_FromLong(0);
inline
                       
PyBool_FromLong will not be inlined into unicode_istitle because its definition is unavailable 
unicode_istitle
11855
            previous_is_cased = 1;
11856
            cased = 1;
11857
        }
11858
        else if (Py_UNICODE_ISLOWER(ch)) {
inline
                 
_PyUnicode_IsLowercase will not be inlined into unicode_istitle because its definition is unavailable 
unicode_istitle
11859
            if (!previous_is_cased)
11860
                return PyBool_FromLong(0);
inline
                       
PyBool_FromLong will not be inlined into unicode_istitle because its definition is unavailable 
unicode_istitle
11861
            previous_is_cased = 1;
11862
            cased = 1;
11863
        }
11864
        else
11865
            previous_is_cased = 0;
11866
    }
11867
    return PyBool_FromLong(cased);
inline
           
PyBool_FromLong will not be inlined into unicode_istitle because its definition is unavailable 
unicode_istitle
11868
}
11869
11870
PyDoc_STRVAR(isspace__doc__,
11871
             "S.isspace() -> bool\n\
11872
\n\
11873
Return True if all characters in S are whitespace\n\
11874
and there is at least one character in S, False otherwise.");
11875
11876
static PyObject*
11877
unicode_isspace(PyObject *self)
11878
{
11879
    Py_ssize_t i, length;
11880
    int kind;
11881
    void *data;
11882
11883
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_isspace
inline
        
_PyUnicode_Ready will not be inlined into unicode_isspace 
unicode_isspace
11884
        return NULL;
11885
    length = PyUnicode_GET_LENGTH(self);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_isspace
11886
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_isspace
gvn
           
load eliminated by PRE 
unicode_isspace
11887
    data = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_isspace
11888
11889
    /* Shortcut for single character strings */
11890
    if (length == 1)
11891
        return PyBool_FromLong(
inline
               
PyBool_FromLong will not be inlined into unicode_isspace because its definition is unavailable 
unicode_isspace
11892
            Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, 0)));
inline
            
_PyUnicode_IsWhitespace will not be inlined into unicode_isspace because its definition is unavailable 
unicode_isspace
gvn
            
load of type i8 eliminated in favor of phi 
unicode_isspace
11893
11894
    /* Special case for empty strings */
11895
    if (length == 0)
11896
        return PyBool_FromLong(0);
inline
               
PyBool_FromLong will not be inlined into unicode_isspace because its definition is unavailable 
unicode_isspace
11897
11898
    for (i = 0; i < length; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_isspace
loop-vectorize
    
loop not vectorized 
unicode_isspace
11899
        const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
licm
                           
hosting trunc 
unicode_isspace
licm
                           
hosting bitcast 
unicode_isspace
11900
        if (!Py_UNICODE_ISSPACE(ch))
inline
             
_PyUnicode_IsWhitespace will not be inlined into unicode_isspace because its definition is unavailable 
unicode_isspace
11901
            return PyBool_FromLong(0);
inline
                   
PyBool_FromLong will not be inlined into unicode_isspace because its definition is unavailable 
unicode_isspace
11902
    }
11903
    return PyBool_FromLong(1);
inline
           
PyBool_FromLong will not be inlined into unicode_isspace because its definition is unavailable 
unicode_isspace
11904
}
11905
11906
PyDoc_STRVAR(isalpha__doc__,
11907
             "S.isalpha() -> bool\n\
11908
\n\
11909
Return True if all characters in S are alphabetic\n\
11910
and there is at least one character in S, False otherwise.");
11911
11912
static PyObject*
11913
unicode_isalpha(PyObject *self)
11914
{
11915
    Py_ssize_t i, length;
11916
    int kind;
11917
    void *data;
11918
11919
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_isalpha
inline
        
_PyUnicode_Ready will not be inlined into unicode_isalpha 
unicode_isalpha
11920
        return NULL;
11921
    length = PyUnicode_GET_LENGTH(self);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_isalpha
11922
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_isalpha
gvn
           
load eliminated by PRE 
unicode_isalpha
11923
    data = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_isalpha
11924
11925
    /* Shortcut for single character strings */
11926
    if (length == 1)
11927
        return PyBool_FromLong(
11928
            Py_UNICODE_ISALPHA(PyUnicode_READ(kind, data, 0)));
inline
            
_PyUnicode_IsAlpha will not be inlined into unicode_isalpha because its definition is unavailable 
unicode_isalpha
11929
11930
    /* Special case for empty strings */
11931
    if (length == 0)
11932
        return PyBool_FromLong(0);
11933
11934
    for (i = 0; i < length; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_isalpha
loop-vectorize
    
loop not vectorized 
unicode_isalpha
11935
        if (!Py_UNICODE_ISALPHA(PyUnicode_READ(kind, data, i)))
inline
             
_PyUnicode_IsAlpha will not be inlined into unicode_isalpha because its definition is unavailable 
unicode_isalpha
licm
             
hosting trunc 
unicode_isalpha
licm
             
hosting bitcast 
unicode_isalpha
11936
            return PyBool_FromLong(0);
11937
    }
11938
    return PyBool_FromLong(1);
inline
           
PyBool_FromLong will not be inlined into unicode_isalpha because its definition is unavailable 
unicode_isalpha
11939
}
11940
11941
PyDoc_STRVAR(isalnum__doc__,
11942
             "S.isalnum() -> bool\n\
11943
\n\
11944
Return True if all characters in S are alphanumeric\n\
11945
and there is at least one character in S, False otherwise.");
11946
11947
static PyObject*
11948
unicode_isalnum(PyObject *self)
11949
{
11950
    int kind;
11951
    void *data;
11952
    Py_ssize_t len, i;
11953
11954
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_isalnum
inline
        
_PyUnicode_Ready will not be inlined into unicode_isalnum 
unicode_isalnum
11955
        return NULL;
11956
11957
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_isalnum
gvn
           
load eliminated by PRE 
unicode_isalnum
11958
    data = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_isalnum
11959
    len = PyUnicode_GET_LENGTH(self);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
unicode_isalnum
11960
11961
    /* Shortcut for single character strings */
11962
    if (len == 1) {
11963
        const Py_UCS4 ch = PyUnicode_READ(kind, data, 0);
11964
        return PyBool_FromLong(Py_UNICODE_ISALNUM(ch));
inline
                               
_PyUnicode_IsAlpha will not be inlined into unicode_isalnum because its definition is unavailable 
unicode_isalnum
inline
                               
_PyUnicode_IsDecimalDigit will not be inlined into unicode_isalnum because its definition is unavailable 
unicode_isalnum
inline
                               
_PyUnicode_IsDigit will not be inlined into unicode_isalnum because its definition is unavailable 
unicode_isalnum
inline
                               
_PyUnicode_IsNumeric will not be inlined into unicode_isalnum because its definition is unavailable 
unicode_isalnum
inline
               
PyBool_FromLong will not be inlined into unicode_isalnum because its definition is unavailable 
unicode_isalnum
11965
    }
11966
11967
    /* Special case for empty strings */
11968
    if (len == 0)
11969
        return PyBool_FromLong(0);
inline
               
PyBool_FromLong will not be inlined into unicode_isalnum because its definition is unavailable 
unicode_isalnum
11970
11971
    for (i = 0; i < len; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_isalnum
loop-vectorize
    
loop not vectorized 
unicode_isalnum
11972
        const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
licm
                           
hosting trunc 
unicode_isalnum
licm
                           
hosting bitcast 
unicode_isalnum
11973
        if (!Py_UNICODE_ISALNUM(ch))
inline
             
_PyUnicode_IsAlpha will not be inlined into unicode_isalnum because its definition is unavailable 
unicode_isalnum
inline
             
_PyUnicode_IsDecimalDigit will not be inlined into unicode_isalnum because its definition is unavailable 
unicode_isalnum
inline
             
_PyUnicode_IsDigit will not be inlined into unicode_isalnum because its definition is unavailable 
unicode_isalnum
inline
             
_PyUnicode_IsNumeric will not be inlined into unicode_isalnum because its definition is unavailable 
unicode_isalnum
11974
            return PyBool_FromLong(0);
inline
                   
PyBool_FromLong will not be inlined into unicode_isalnum because its definition is unavailable 
unicode_isalnum
11975
    }
11976
    return PyBool_FromLong(1);
inline
           
PyBool_FromLong will not be inlined into unicode_isalnum because its definition is unavailable 
unicode_isalnum
11977
}
11978
11979
PyDoc_STRVAR(isdecimal__doc__,
11980
             "S.isdecimal() -> bool\n\
11981
\n\
11982
Return True if there are only decimal characters in S,\n\
11983
False otherwise.");
11984
11985
static PyObject*
11986
unicode_isdecimal(PyObject *self)
11987
{
11988
    Py_ssize_t i, length;
11989
    int kind;
11990
    void *data;
11991
11992
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_isdecimal
inline
        
_PyUnicode_Ready will not be inlined into unicode_isdecimal 
unicode_isdecimal
11993
        return NULL;
11994
    length = PyUnicode_GET_LENGTH(self);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_isdecimal
11995
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_isdecimal
gvn
           
load eliminated by PRE 
unicode_isdecimal
11996
    data = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_isdecimal
11997
11998
    /* Shortcut for single character strings */
11999
    if (length == 1)
12000
        return PyBool_FromLong(
12001
            Py_UNICODE_ISDECIMAL(PyUnicode_READ(kind, data, 0)));
inline
            
_PyUnicode_IsDecimalDigit will not be inlined into unicode_isdecimal because its definition is unavailable 
unicode_isdecimal
12002
12003
    /* Special case for empty strings */
12004
    if (length == 0)
12005
        return PyBool_FromLong(0);
12006
12007
    for (i = 0; i < length; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_isdecimal
loop-vectorize
    
loop not vectorized 
unicode_isdecimal
12008
        if (!Py_UNICODE_ISDECIMAL(PyUnicode_READ(kind, data, i)))
inline
             
_PyUnicode_IsDecimalDigit will not be inlined into unicode_isdecimal because its definition is unavailable 
unicode_isdecimal
licm
             
hosting trunc 
unicode_isdecimal
licm
             
hosting bitcast 
unicode_isdecimal
12009
            return PyBool_FromLong(0);
12010
    }
12011
    return PyBool_FromLong(1);
inline
           
PyBool_FromLong will not be inlined into unicode_isdecimal because its definition is unavailable 
unicode_isdecimal
12012
}
12013
12014
PyDoc_STRVAR(isdigit__doc__,
12015
             "S.isdigit() -> bool\n\
12016
\n\
12017
Return True if all characters in S are digits\n\
12018
and there is at least one character in S, False otherwise.");
12019
12020
static PyObject*
12021
unicode_isdigit(PyObject *self)
12022
{
12023
    Py_ssize_t i, length;
12024
    int kind;
12025
    void *data;
12026
12027
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_isdigit
inline
        
_PyUnicode_Ready will not be inlined into unicode_isdigit 
unicode_isdigit
12028
        return NULL;
12029
    length = PyUnicode_GET_LENGTH(self);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_isdigit
12030
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_isdigit
gvn
           
load eliminated by PRE 
unicode_isdigit
12031
    data = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_isdigit
12032
12033
    /* Shortcut for single character strings */
12034
    if (length == 1) {
12035
        const Py_UCS4 ch = PyUnicode_READ(kind, data, 0);
12036
        return PyBool_FromLong(Py_UNICODE_ISDIGIT(ch));
inline
                               
_PyUnicode_IsDigit will not be inlined into unicode_isdigit because its definition is unavailable 
unicode_isdigit
12037
    }
12038
12039
    /* Special case for empty strings */
12040
    if (length == 0)
12041
        return PyBool_FromLong(0);
12042
12043
    for (i = 0; i < length; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_isdigit
loop-vectorize
    
loop not vectorized 
unicode_isdigit
12044
        if (!Py_UNICODE_ISDIGIT(PyUnicode_READ(kind, data, i)))
inline
             
_PyUnicode_IsDigit will not be inlined into unicode_isdigit because its definition is unavailable 
unicode_isdigit
licm
             
hosting trunc 
unicode_isdigit
licm
             
hosting bitcast 
unicode_isdigit
12045
            return PyBool_FromLong(0);
12046
    }
12047
    return PyBool_FromLong(1);
inline
           
PyBool_FromLong will not be inlined into unicode_isdigit because its definition is unavailable 
unicode_isdigit
12048
}
12049
12050
PyDoc_STRVAR(isnumeric__doc__,
12051
             "S.isnumeric() -> bool\n\
12052
\n\
12053
Return True if there are only numeric characters in S,\n\
12054
False otherwise.");
12055
12056
static PyObject*
12057
unicode_isnumeric(PyObject *self)
12058
{
12059
    Py_ssize_t i, length;
12060
    int kind;
12061
    void *data;
12062
12063
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_isnumeric
inline
        
_PyUnicode_Ready will not be inlined into unicode_isnumeric 
unicode_isnumeric
12064
        return NULL;
12065
    length = PyUnicode_GET_LENGTH(self);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_isnumeric
12066
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_isnumeric
gvn
           
load eliminated by PRE 
unicode_isnumeric
12067
    data = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_isnumeric
12068
12069
    /* Shortcut for single character strings */
12070
    if (length == 1)
12071
        return PyBool_FromLong(
12072
            Py_UNICODE_ISNUMERIC(PyUnicode_READ(kind, data, 0)));
inline
            
_PyUnicode_IsNumeric will not be inlined into unicode_isnumeric because its definition is unavailable 
unicode_isnumeric
12073
12074
    /* Special case for empty strings */
12075
    if (length == 0)
12076
        return PyBool_FromLong(0);
12077
12078
    for (i = 0; i < length; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_isnumeric
loop-vectorize
    
loop not vectorized 
unicode_isnumeric
12079
        if (!Py_UNICODE_ISNUMERIC(PyUnicode_READ(kind, data, i)))
inline
             
_PyUnicode_IsNumeric will not be inlined into unicode_isnumeric because its definition is unavailable 
unicode_isnumeric
licm
             
hosting trunc 
unicode_isnumeric
licm
             
hosting bitcast 
unicode_isnumeric
12080
            return PyBool_FromLong(0);
12081
    }
12082
    return PyBool_FromLong(1);
inline
           
PyBool_FromLong will not be inlined into unicode_isnumeric because its definition is unavailable 
unicode_isnumeric
12083
}
12084
12085
int
12086
PyUnicode_IsIdentifier(PyObject *self)
12087
{
12088
    int kind;
12089
    void *data;
12090
    Py_ssize_t i;
12091
    Py_UCS4 first;
12092
12093
    if (PyUnicode_READY(self) == -1) {
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_IsIdentifier
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_IsIdentifier 
PyUnicode_IsIdentifier
12094
        Py_FatalError("identifier not ready");
inline
        
Py_FatalError will not be inlined into PyUnicode_IsIdentifier because its definition is unavailable 
PyUnicode_IsIdentifier
12095
        return 0;
12096
    }
12097
12098
    /* Special case for empty strings */
12099
    if (PyUnicode_GET_LENGTH(self) == 0)
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_IsIdentifier
12100
        return 0;
12101
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_IsIdentifier
12102
    data = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_IsIdentifier
12103
12104
    /* PEP 3131 says that the first character must be in
12105
       XID_Start and subsequent characters in XID_Continue,
12106
       and for the ASCII range, the 2.x rules apply (i.e
12107
       start with letters and underscore, continue with
12108
       letters, digits, underscore). However, given the current
12109
       definition of XID_Start and XID_Continue, it is sufficient
12110
       to check just for these, except that _ must be allowed
12111
       as starting an identifier.  */
12112
    first = PyUnicode_READ(kind, data, 0);
12113
    if (!_PyUnicode_IsXidStart(first) && first != 0x5F /* LOW LINE */)
inline
         
_PyUnicode_IsXidStart will not be inlined into PyUnicode_IsIdentifier because its definition is unavailable 
PyUnicode_IsIdentifier
12114
        return 0;
12115
12116
    for (i = 1; i < PyUnicode_GET_LENGTH(self); i++)
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_IsIdentifier
gvn
                    
load of type i64 not eliminated in favor of load because it is clobbered by call 
PyUnicode_IsIdentifier
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_IsIdentifier
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_IsIdentifier
loop-vectorize
    
loop not vectorized 
PyUnicode_IsIdentifier
12117
        if (!_PyUnicode_IsXidContinue(PyUnicode_READ(kind, data, i)))
inline
             
_PyUnicode_IsXidContinue will not be inlined into PyUnicode_IsIdentifier because its definition is unavailable 
PyUnicode_IsIdentifier
licm
                                      
hosting icmp 
PyUnicode_IsIdentifier
licm
                                      
hosting bitcast 
PyUnicode_IsIdentifier
12118
            return 0;
12119
    return 1;
12120
}
12121
12122
PyDoc_STRVAR(isidentifier__doc__,
12123
             "S.isidentifier() -> bool\n\
12124
\n\
12125
Return True if S is a valid identifier according\n\
12126
to the language definition.\n\
12127
\n\
12128
Use keyword.iskeyword() to test for reserved identifiers\n\
12129
such as \"def\" and \"class\".\n");
12130
12131
static PyObject*
12132
unicode_isidentifier(PyObject *self)
12133
{
12134
    return PyBool_FromLong(PyUnicode_IsIdentifier(self));
inline
           
PyBool_FromLong will not be inlined into unicode_isidentifier because its definition is unavailable 
unicode_isidentifier
inline
                           
PyUnicode_IsIdentifier too costly to inline (cost=490, threshold=250) 
unicode_isidentifier
inline
                           
PyUnicode_IsIdentifier will not be inlined into unicode_isidentifier 
unicode_isidentifier
12135
}
12136
12137
PyDoc_STRVAR(isprintable__doc__,
12138
             "S.isprintable() -> bool\n\
12139
\n\
12140
Return True if all characters in S are considered\n\
12141
printable in repr() or S is empty, False otherwise.");
12142
12143
static PyObject*
12144
unicode_isprintable(PyObject *self)
12145
{
12146
    Py_ssize_t i, length;
12147
    int kind;
12148
    void *data;
12149
12150
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_isprintable
inline
        
_PyUnicode_Ready will not be inlined into unicode_isprintable 
unicode_isprintable
12151
        return NULL;
12152
    length = PyUnicode_GET_LENGTH(self);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_isprintable
12153
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_isprintable
gvn
           
load eliminated by PRE 
unicode_isprintable
12154
    data = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_isprintable
12155
12156
    /* Shortcut for single character strings */
12157
    if (length == 1)
12158
        return PyBool_FromLong(
inline
               
PyBool_FromLong will not be inlined into unicode_isprintable because its definition is unavailable 
unicode_isprintable
12159
            Py_UNICODE_ISPRINTABLE(PyUnicode_READ(kind, data, 0)));
inline
            
_PyUnicode_IsPrintable will not be inlined into unicode_isprintable because its definition is unavailable 
unicode_isprintable
12160
12161
    for (i = 0; i < length; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_isprintable
loop-vectorize
    
loop not vectorized 
unicode_isprintable
12162
        if (!Py_UNICODE_ISPRINTABLE(PyUnicode_READ(kind, data, i))) {
inline
             
_PyUnicode_IsPrintable will not be inlined into unicode_isprintable because its definition is unavailable 
unicode_isprintable
licm
             
hosting trunc 
unicode_isprintable
licm
             
hosting bitcast 
unicode_isprintable
12163
            Py_RETURN_FALSE;
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_isprintable
12164
        }
12165
    }
12166
    Py_RETURN_TRUE;
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_isprintable
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_isprintable
12167
}
12168
12169
PyDoc_STRVAR(join__doc__,
12170
             "S.join(iterable) -> str\n\
12171
\n\
12172
Return a string which is the concatenation of the strings in the\n\
12173
iterable.  The separator between elements is S.");
12174
12175
static PyObject*
12176
unicode_join(PyObject *self, PyObject *data)
12177
{
12178
    return PyUnicode_Join(self, data);
inline
           
PyUnicode_Join can be inlined into unicode_join with cost=135 (threshold=250) 
unicode_join
inline
           
PyUnicode_Join inlined into unicode_join 
unicode_join
12179
}
12180
12181
static Py_ssize_t
12182
unicode_length(PyObject *self)
12183
{
12184
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_length
inline
        
_PyUnicode_Ready will not be inlined into unicode_length 
unicode_length
12185
        return -1;
12186
    return PyUnicode_GET_LENGTH(self);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
unicode_length
12187
}
12188
12189
PyDoc_STRVAR(ljust__doc__,
12190
             "S.ljust(width[, fillchar]) -> str\n\
12191
\n\
12192
Return S left-justified in a Unicode string of length width. Padding is\n\
12193
done using the specified fill character (default is a space).");
12194
12195
static PyObject *
12196
unicode_ljust(PyObject *self, PyObject *args)
12197
{
12198
    Py_ssize_t width;
12199
    Py_UCS4 fillchar = ' ';
12200
12201
    if (!PyArg_ParseTuple(args, "n|O&:ljust", &width, convert_uc, &fillchar))
inline
         
_PyArg_ParseTuple_SizeT will not be inlined into unicode_ljust because its definition is unavailable 
unicode_ljust
12202
        return NULL;
12203
12204
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_ljust
inline
        
_PyUnicode_Ready will not be inlined into unicode_ljust 
unicode_ljust
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_ljust
12205
        return NULL;
12206
12207
    if (PyUnicode_GET_LENGTH(self) >= width)
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_ljust
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_ljust
gvn
                                      
load of type i64 not eliminated because it is clobbered by call 
unicode_ljust
gvn
                                      
load of type i64 not eliminated because it is clobbered by call 
unicode_ljust
12208
        return unicode_result_unchanged(self);
inline
               
unicode_result_unchanged can be inlined into unicode_ljust with cost=90 (threshold=250) 
unicode_ljust
inline
               
unicode_result_unchanged inlined into unicode_ljust 
unicode_ljust
12209
12210
    return pad(self, 0, width - PyUnicode_GET_LENGTH(self), fillchar);
inline
           
pad too costly to inline (cost=540, threshold=250) 
unicode_ljust
inline
           
pad will not be inlined into unicode_ljust 
unicode_ljust
gvn
                                                            
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_ljust
gvn
                                                            
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_ljust
12211
}
12212
12213
PyDoc_STRVAR(lower__doc__,
12214
             "S.lower() -> str\n\
12215
\n\
12216
Return a copy of the string S converted to lowercase.");
12217
12218
static PyObject*
12219
unicode_lower(PyObject *self)
12220
{
12221
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_lower
inline
        
_PyUnicode_Ready will not be inlined into unicode_lower 
unicode_lower
12222
        return NULL;
12223
    if (PyUnicode_IS_ASCII(self))
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_lower
gvn
        
load eliminated by PRE 
unicode_lower
12224
        return ascii_upper_or_lower(self, 1);
inline
               
ascii_upper_or_lower can be inlined into unicode_lower with cost=140 (threshold=250) 
unicode_lower
inline
               
ascii_upper_or_lower inlined into unicode_lower 
unicode_lower
12225
    return case_operation(self, do_lower);
inline
           
case_operation too costly to inline (cost=435, threshold=250) 
unicode_lower
inline
           
case_operation will not be inlined into unicode_lower 
unicode_lower
12226
}
12227
12228
#define LEFTSTRIP 0
12229
#define RIGHTSTRIP 1
12230
#define BOTHSTRIP 2
12231
12232
/* Arrays indexed by above */
12233
static const char * const stripformat[] = {"|O:lstrip", "|O:rstrip", "|O:strip"};
12234
12235
#define STRIPNAME(i) (stripformat[i]+3)
12236
12237
/* externally visible for str.strip(unicode) */
12238
PyObject *
12239
_PyUnicode_XStrip(PyObject *self, int striptype, PyObject *sepobj)
12240
{
12241
    void *data;
12242
    int kind;
12243
    Py_ssize_t i, j, len;
12244
    BLOOM_MASK sepmask;
12245
    Py_ssize_t seplen;
12246
12247
    if (PyUnicode_READY(self) == -1 || PyUnicode_READY(sepobj) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_XStrip
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicode_XStrip 
_PyUnicode_XStrip
inline
                                       
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicode_XStrip
inline
                                       
_PyUnicode_Ready will not be inlined into _PyUnicode_XStrip 
_PyUnicode_XStrip
gvn
                                       
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_XStrip
12248
        return NULL;
12249
12250
    kind = PyUnicode_KIND(self);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_XStrip
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_XStrip
12251
    data = PyUnicode_DATA(self);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_XStrip
gvn
           
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_XStrip
12252
    len = PyUnicode_GET_LENGTH(self);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_XStrip
gvn
          
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_XStrip
12253
    seplen = PyUnicode_GET_LENGTH(sepobj);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_XStrip
gvn
             
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_XStrip
12254
    sepmask = make_bloom_mask(PyUnicode_KIND(sepobj),
inline
              
make_bloom_mask can be inlined into _PyUnicode_XStrip with cost=120 (threshold=325) 
_PyUnicode_XStrip
inline
              
make_bloom_mask inlined into _PyUnicode_XStrip 
_PyUnicode_XStrip
gvn
                              
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicode_XStrip
12255
                              PyUnicode_DATA(sepobj),
gvn
                              
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_XStrip
gvn
                              
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_XStrip
12256
                              seplen);
12257
12258
    i = 0;
12259
    if (striptype != RIGHTSTRIP) {
12260
        while (i < len) {
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_XStrip
loop-vectorize
        
loop not vectorized 
_PyUnicode_XStrip
12261
            Py_UCS4 ch = PyUnicode_READ(kind, data, i);
licm
                         
hosting trunc 
_PyUnicode_XStrip
licm
                         
hosting bitcast 
_PyUnicode_XStrip
12262
            if (!BLOOM(sepmask, ch))
12263
                break;
12264
            if (PyUnicode_FindChar(sepobj, ch, 0, seplen, 1) < 0)
inline
                
PyUnicode_FindChar too costly to inline (cost=630, threshold=625) 
_PyUnicode_XStrip
inline
                
PyUnicode_FindChar will not be inlined into _PyUnicode_XStrip 
_PyUnicode_XStrip
12265
                break;
12266
            i++;
12267
        }
12268
    }
12269
12270
    j = len;
12271
    if (striptype != LEFTSTRIP) {
12272
        j--;
12273
        while (j >= i) {
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
_PyUnicode_XStrip
loop-vectorize
        
loop not vectorized 
_PyUnicode_XStrip
12274
            Py_UCS4 ch = PyUnicode_READ(kind, data, j);
licm
                         
hosting trunc 
_PyUnicode_XStrip
licm
                         
hosting bitcast 
_PyUnicode_XStrip
12275
            if (!BLOOM(sepmask, ch))
12276
                break;
12277
            if (PyUnicode_FindChar(sepobj, ch, 0, seplen, 1) < 0)
inline
                
PyUnicode_FindChar too costly to inline (cost=630, threshold=625) 
_PyUnicode_XStrip
inline
                
PyUnicode_FindChar will not be inlined into _PyUnicode_XStrip 
_PyUnicode_XStrip
12278
                break;
12279
            j--;
12280
        }
12281
12282
        j++;
12283
    }
12284
12285
    return PyUnicode_Substring(self, i, j);
inline
           
PyUnicode_Substring too costly to inline (cost=630, threshold=625) 
_PyUnicode_XStrip
inline
           
PyUnicode_Substring will not be inlined into _PyUnicode_XStrip 
_PyUnicode_XStrip
12286
}
12287
12288
PyObject*
12289
PyUnicode_Substring(PyObject *self, Py_ssize_t start, Py_ssize_t end)
12290
{
12291
    unsigned char *data;
12292
    int kind;
12293
    Py_ssize_t length;
12294
12295
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Substring
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_Substring 
PyUnicode_Substring
12296
        return NULL;
12297
12298
    length = PyUnicode_GET_LENGTH(self);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Substring
12299
    end = Py_MIN(end, length);
12300
12301
    if (start == 0 && end == length)
12302
        return unicode_result_unchanged(self);
inline
               
unicode_result_unchanged can be inlined into PyUnicode_Substring with cost=90 (threshold=250) 
PyUnicode_Substring
inline
               
unicode_result_unchanged inlined into PyUnicode_Substring 
PyUnicode_Substring
12303
12304
    if (start < 0 || end < 0) {
12305
        PyErr_SetString(PyExc_IndexError, "string index out of range");
inline
        
PyErr_SetString will not be inlined into PyUnicode_Substring because its definition is unavailable 
PyUnicode_Substring
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Substring
12306
        return NULL;
12307
    }
12308
    if (start >= length || end < start)
12309
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_Substring
inline
        
PyUnicode_New will not be inlined into PyUnicode_Substring 
PyUnicode_Substring
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Substring
gvn
        
load of type %struct._object* eliminated in favor of phi 
PyUnicode_Substring
12310
12311
    length = end - start;
12312
    if (PyUnicode_IS_ASCII(self)) {
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Substring
12313
        data = PyUnicode_1BYTE_DATA(self);
gvn
               
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Substring
12314
        return _PyUnicode_FromASCII((char*)(data + start), length);
inline
               
_PyUnicode_FromASCII can be inlined into PyUnicode_Substring with cost=215 (threshold=250) 
PyUnicode_Substring
inline
               
_PyUnicode_FromASCII inlined into PyUnicode_Substring 
PyUnicode_Substring
12315
    }
12316
    else {
12317
        kind = PyUnicode_KIND(self);
12318
        data = PyUnicode_1BYTE_DATA(self);
gvn
               
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Substring
12319
        return PyUnicode_FromKindAndData(kind,
inline
               
PyUnicode_FromKindAndData can be inlined into PyUnicode_Substring with cost=195 (threshold=250) 
PyUnicode_Substring
inline
               
PyUnicode_FromKindAndData inlined into PyUnicode_Substring 
PyUnicode_Substring
12320
                                         data + kind * start,
12321
                                         length);
12322
    }
12323
}
12324
12325
static PyObject *
12326
do_strip(PyObject *self, int striptype)
12327
{
12328
    Py_ssize_t len, i, j;
12329
12330
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
do_strip
inline
        
_PyUnicode_Ready will not be inlined into do_strip 
do_strip
12331
        return NULL;
12332
12333
    len = PyUnicode_GET_LENGTH(self);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
do_strip
12334
12335
    if (PyUnicode_IS_ASCII(self)) {
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
do_strip
gvn
        
load eliminated by PRE 
do_strip
12336
        Py_UCS1 *data = PyUnicode_1BYTE_DATA(self);
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
do_strip
12337
12338
        i = 0;
12339
        if (striptype != RIGHTSTRIP) {
12340
            while (i < len) {
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
do_strip
loop-vectorize
            
loop not vectorized 
do_strip
12341
                Py_UCS1 ch = data[i];
gvn
                             
load of type i8 not eliminated because it is clobbered by call 
do_strip
12342
                if (!_Py_ascii_whitespace[ch])
12343
                    break;
12344
                i++;
12345
            }
12346
        }
12347
12348
        j = len;
12349
        if (striptype != LEFTSTRIP) {
12350
            j--;
12351
            while (j >= i) {
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
do_strip
loop-vectorize
            
loop not vectorized 
do_strip
12352
                Py_UCS1 ch = data[j];
12353
                if (!_Py_ascii_whitespace[ch])
12354
                    break;
12355
                j--;
12356
            }
12357
            j++;
12358
        }
12359
    }
12360
    else {
12361
        int kind = PyUnicode_KIND(self);
12362
        void *data = PyUnicode_DATA(self);
gvn
                     
load of type i8* not eliminated because it is clobbered by call 
do_strip
12363
12364
        i = 0;
12365
        if (striptype != RIGHTSTRIP) {
12366
            while (i < len) {
12367
                Py_UCS4 ch = PyUnicode_READ(kind, data, i);
licm
                             
hosting trunc 
do_strip
licm
                             
hosting bitcast 
do_strip
gvn
                             
load of type i8 not eliminated because it is clobbered by call 
do_strip
loop-vectorize
                             
loop not vectorized: loop control flow is not understood by vectorizer 
do_strip
loop-vectorize
                             
loop not vectorized 
do_strip
12368
                if (!Py_UNICODE_ISSPACE(ch))
inline
                     
_PyUnicode_IsWhitespace will not be inlined into do_strip because its definition is unavailable 
do_strip
12369
                    break;
12370
                i++;
12371
            }
12372
        }
12373
12374
        j = len;
12375
        if (striptype != LEFTSTRIP) {
12376
            j--;
12377
            while (j >= i) {
12378
                Py_UCS4 ch = PyUnicode_READ(kind, data, j);
licm
                             
hosting trunc 
do_strip
licm
                             
hosting bitcast 
do_strip
loop-vectorize
                             
loop not vectorized: loop control flow is not understood by vectorizer 
do_strip
loop-vectorize
                             
loop not vectorized 
do_strip
12379
                if (!Py_UNICODE_ISSPACE(ch))
inline
                     
_PyUnicode_IsWhitespace will not be inlined into do_strip because its definition is unavailable 
do_strip
12380
                    break;
12381
                j--;
12382
            }
12383
            j++;
12384
        }
12385
    }
12386
12387
    return PyUnicode_Substring(self, i, j);
inline
           
PyUnicode_Substring too costly to inline (cost=630, threshold=625) 
do_strip
inline
           
PyUnicode_Substring will not be inlined into do_strip 
do_strip
12388
}
12389
12390
12391
static PyObject *
12392
do_argstrip(PyObject *self, int striptype, PyObject *args)
12393
{
12394
    PyObject *sep = NULL;
12395
12396
    if (!PyArg_ParseTuple(args, stripformat[striptype], &sep))
inline
         
_PyArg_ParseTuple_SizeT will not be inlined into do_argstrip because its definition is unavailable 
do_argstrip
12397
        return NULL;
12398
12399
    if (sep != NULL && sep != Py_None) {
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
do_argstrip
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_lstrip
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_rstrip
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_strip
12400
        if (PyUnicode_Check(sep))
12401
            return _PyUnicode_XStrip(self, striptype, sep);
inline
                   
_PyUnicode_XStrip too costly to inline (cost=630, threshold=625) 
do_argstrip
inline
                   
_PyUnicode_XStrip will not be inlined into do_argstrip 
do_argstrip
inline
                   
_PyUnicode_XStrip too costly to inline (cost=680, threshold=625) 
unicode_lstrip
inline
                   
_PyUnicode_XStrip will not be inlined into unicode_lstrip 
unicode_lstrip
inline
                   
_PyUnicode_XStrip too costly to inline (cost=630, threshold=625) 
unicode_rstrip
inline
                   
_PyUnicode_XStrip will not be inlined into unicode_rstrip 
unicode_rstrip
inline
                   
_PyUnicode_XStrip too costly to inline (cost=655, threshold=625) 
unicode_strip
inline
                   
_PyUnicode_XStrip will not be inlined into unicode_strip 
unicode_strip
12402
        else {
12403
            PyErr_Format(PyExc_TypeError,
inline
            
PyErr_Format will not be inlined into do_argstrip because its definition is unavailable 
do_argstrip
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
do_argstrip
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_lstrip
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_rstrip
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_strip
12404
                         "%s arg must be None or str",
12405
                         STRIPNAME(striptype));
gvn
                         
load of type i8* eliminated in favor of load 
do_argstrip
12406
            return NULL;
12407
        }
12408
    }
12409
12410
    return do_strip(self, striptype);
inline
           
do_strip too costly to inline (cost=630, threshold=625) 
do_argstrip
inline
           
do_strip will not be inlined into do_argstrip 
do_argstrip
inline
           
do_strip too costly to inline (cost=530, threshold=250) 
unicode_lstrip
inline
           
do_strip will not be inlined into unicode_lstrip 
unicode_lstrip
inline
           
do_strip too costly to inline (cost=545, threshold=250) 
unicode_rstrip
inline
           
do_strip will not be inlined into unicode_rstrip 
unicode_rstrip
inline
           
do_strip too costly to inline (cost=630, threshold=625) 
unicode_strip
inline
           
do_strip will not be inlined into unicode_strip 
unicode_strip
12411
}
12412
12413
12414
PyDoc_STRVAR(strip__doc__,
12415
             "S.strip([chars]) -> str\n\
12416
\n\
12417
Return a copy of the string S with leading and trailing\n\
12418
whitespace removed.\n\
12419
If chars is given and not None, remove characters in chars instead.");
12420
12421
static PyObject *
12422
unicode_strip(PyObject *self, PyObject *args)
12423
{
12424
    if (PyTuple_GET_SIZE(args) == 0)
12425
        return do_strip(self, BOTHSTRIP); /* Common case */
inline
               
do_strip too costly to inline (cost=630, threshold=625) 
unicode_strip
inline
               
do_strip will not be inlined into unicode_strip 
unicode_strip
12426
    else
12427
        return do_argstrip(self, BOTHSTRIP, args);
inline
               
do_argstrip can be inlined into unicode_strip with cost=-14790 (threshold=250) 
unicode_strip
inline
               
do_argstrip inlined into unicode_strip 
unicode_strip
12428
}
12429
12430
12431
PyDoc_STRVAR(lstrip__doc__,
12432
             "S.lstrip([chars]) -> str\n\
12433
\n\
12434
Return a copy of the string S with leading whitespace removed.\n\
12435
If chars is given and not None, remove characters in chars instead.");
12436
12437
static PyObject *
12438
unicode_lstrip(PyObject *self, PyObject *args)
12439
{
12440
    if (PyTuple_GET_SIZE(args) == 0)
12441
        return do_strip(self, LEFTSTRIP); /* Common case */
inline
               
do_strip too costly to inline (cost=530, threshold=250) 
unicode_lstrip
inline
               
do_strip will not be inlined into unicode_lstrip 
unicode_lstrip
12442
    else
12443
        return do_argstrip(self, LEFTSTRIP, args);
inline
               
do_argstrip can be inlined into unicode_lstrip with cost=210 (threshold=250) 
unicode_lstrip
inline
               
do_argstrip inlined into unicode_lstrip 
unicode_lstrip
12444
}
12445
12446
12447
PyDoc_STRVAR(rstrip__doc__,
12448
             "S.rstrip([chars]) -> str\n\
12449
\n\
12450
Return a copy of the string S with trailing whitespace removed.\n\
12451
If chars is given and not None, remove characters in chars instead.");
12452
12453
static PyObject *
12454
unicode_rstrip(PyObject *self, PyObject *args)
12455
{
12456
    if (PyTuple_GET_SIZE(args) == 0)
12457
        return do_strip(self, RIGHTSTRIP); /* Common case */
inline
               
do_strip too costly to inline (cost=545, threshold=250) 
unicode_rstrip
inline
               
do_strip will not be inlined into unicode_rstrip 
unicode_rstrip
12458
    else
12459
        return do_argstrip(self, RIGHTSTRIP, args);
inline
               
do_argstrip can be inlined into unicode_rstrip with cost=210 (threshold=250) 
unicode_rstrip
inline
               
do_argstrip inlined into unicode_rstrip 
unicode_rstrip
12460
}
12461
12462
12463
static PyObject*
12464
unicode_repeat(PyObject *str, Py_ssize_t len)
12465
{
12466
    PyObject *u;
12467
    Py_ssize_t nchars, n;
12468
12469
    if (len < 1)
12470
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
unicode_repeat
inline
        
PyUnicode_New will not be inlined into unicode_repeat 
unicode_repeat
gvn
        
load of type %struct._object* eliminated in favor of phi 
unicode_repeat
12471
12472
    /* no repeat, return original string */
12473
    if (len == 1)
12474
        return unicode_result_unchanged(str);
inline
               
unicode_result_unchanged can be inlined into unicode_repeat with cost=90 (threshold=250) 
unicode_repeat
inline
               
unicode_result_unchanged inlined into unicode_repeat 
unicode_repeat
12475
12476
    if (PyUnicode_READY(str) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_repeat
inline
        
_PyUnicode_Ready will not be inlined into unicode_repeat 
unicode_repeat
12477
        return NULL;
12478
12479
    if (PyUnicode_GET_LENGTH(str) > PY_SSIZE_T_MAX / len) {
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_repeat
12480
        PyErr_SetString(PyExc_OverflowError,
inline
        
PyErr_SetString will not be inlined into unicode_repeat because its definition is unavailable 
unicode_repeat
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_repeat
12481
                        "repeated string is too long");
12482
        return NULL;
12483
    }
12484
    nchars = len * PyUnicode_GET_LENGTH(str);
12485
12486
    u = PyUnicode_New(nchars, PyUnicode_MAX_CHAR_VALUE(str));
inline
        
PyUnicode_New too costly to inline (cost=460, threshold=250) 
unicode_repeat
inline
        
PyUnicode_New will not be inlined into unicode_repeat 
unicode_repeat
gvn
                              
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_repeat
12487
    if (!u)
12488
        return NULL;
12489
    assert(PyUnicode_KIND(u) == PyUnicode_KIND(str));
12490
12491
    if (PyUnicode_GET_LENGTH(str) == 1) {
gvn
        
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_repeat
12492
        const int kind = PyUnicode_KIND(str);
gvn
                         
load of type i32 not eliminated because it is clobbered by call 
unicode_repeat
12493
        const Py_UCS4 fill_char = PyUnicode_READ(kind, PyUnicode_DATA(str), 0);
gvn
                                  
load of type i8* not eliminated because it is clobbered by call 
unicode_repeat
12494
        if (kind == PyUnicode_1BYTE_KIND) {
12495
            void *to = PyUnicode_DATA(u);
gvn
                       
load of type i32 not eliminated because it is clobbered by call 
unicode_repeat
gvn
                       
load of type i8* not eliminated because it is clobbered by call 
unicode_repeat
12496
            memset(to, (unsigned char)fill_char, len);
12497
        }
12498
        else if (kind == PyUnicode_2BYTE_KIND) {
12499
            Py_UCS2 *ucs2 = PyUnicode_2BYTE_DATA(u);
gvn
                            
load of type i8* not eliminated because it is clobbered by call 
unicode_repeat
12500
            for (n = 0; n < len; ++n)
loop-vectorize
            
vectorized loop (vectorization width: 8, interleaved count: 2) 
unicode_repeat
loop-unroll
            
unrolled loop by a factor of 8 with run-time trip count 
unicode_repeat
12501
                ucs2[n] = fill_char;
licm
                          
hosting trunc 
unicode_repeat
12502
        } else {
12503
            Py_UCS4 *ucs4 = PyUnicode_4BYTE_DATA(u);
gvn
                            
load of type i8* not eliminated because it is clobbered by call 
unicode_repeat
12504
            assert(kind == PyUnicode_4BYTE_KIND);
12505
            for (n = 0; n < len; ++n)
loop-vectorize
            
vectorized loop (vectorization width: 4, interleaved count: 2) 
unicode_repeat
loop-unroll
            
unrolled loop by a factor of 8 with run-time trip count 
unicode_repeat
12506
                ucs4[n] = fill_char;
12507
        }
12508
    }
12509
    else {
12510
        /* number of characters copied this far */
12511
        Py_ssize_t done = PyUnicode_GET_LENGTH(str);
12512
        const Py_ssize_t char_size = PyUnicode_KIND(str);
12513
        char *to = (char *) PyUnicode_DATA(u);
gvn
                            
load of type i32 not eliminated because it is clobbered by call 
unicode_repeat
gvn
                            
load of type i8* not eliminated because it is clobbered by call 
unicode_repeat
12514
        memcpy(to, PyUnicode_DATA(str),
gvn
                   
load of type i8* not eliminated because it is clobbered by call 
unicode_repeat
12515
                  PyUnicode_GET_LENGTH(str) * char_size);
gvn
                  
load of type i64 eliminated in favor of load 
unicode_repeat
12516
        while (done < nchars) {
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
unicode_repeat
loop-vectorize
        
loop not vectorized 
unicode_repeat
12517
            n = (done <= nchars-done) ? done : nchars-done;
12518
            memcpy(to + (done * char_size), to, n * char_size);
12519
            done += n;
12520
        }
12521
    }
12522
12523
    assert(_PyUnicode_CheckConsistency(u, 1));
12524
    return u;
12525
}
12526
12527
PyObject *
12528
PyUnicode_Replace(PyObject *str,
12529
                  PyObject *substr,
12530
                  PyObject *replstr,
12531
                  Py_ssize_t maxcount)
12532
{
12533
    if (ensure_unicode(str) < 0 || ensure_unicode(substr) < 0 ||
inline
        
ensure_unicode can be inlined into PyUnicode_Replace with cost=95 (threshold=250) 
PyUnicode_Replace
inline
        
ensure_unicode inlined into PyUnicode_Replace 
PyUnicode_Replace
inline
                                   
ensure_unicode can be inlined into PyUnicode_Replace with cost=95 (threshold=250) 
PyUnicode_Replace
inline
                                   
ensure_unicode inlined into PyUnicode_Replace 
PyUnicode_Replace
12534
            ensure_unicode(replstr) < 0)
inline
            
ensure_unicode can be inlined into PyUnicode_Replace with cost=95 (threshold=250) 
PyUnicode_Replace
inline
            
ensure_unicode inlined into PyUnicode_Replace 
PyUnicode_Replace
12535
        return NULL;
12536
    return replace(str, substr, replstr, maxcount);
inline
           
replace too costly to inline (cost=670, threshold=625) 
PyUnicode_Replace
inline
           
replace will not be inlined into PyUnicode_Replace 
PyUnicode_Replace
12537
}
12538
12539
PyDoc_STRVAR(replace__doc__,
12540
             "S.replace(old, new[, count]) -> str\n\
12541
\n\
12542
Return a copy of S with all occurrences of substring\n\
12543
old replaced by new.  If the optional argument count is\n\
12544
given, only the first count occurrences are replaced.");
12545
12546
static PyObject*
12547
unicode_replace(PyObject *self, PyObject *args)
12548
{
12549
    PyObject *str1;
12550
    PyObject *str2;
12551
    Py_ssize_t maxcount = -1;
12552
12553
    if (!PyArg_ParseTuple(args, "UU|n:replace", &str1, &str2, &maxcount))
inline
         
_PyArg_ParseTuple_SizeT will not be inlined into unicode_replace because its definition is unavailable 
unicode_replace
12554
        return NULL;
12555
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_replace
inline
        
_PyUnicode_Ready will not be inlined into unicode_replace 
unicode_replace
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_replace
12556
        return NULL;
12557
    return replace(self, str1, str2, maxcount);
inline
           
replace too costly to inline (cost=670, threshold=625) 
unicode_replace
inline
           
replace will not be inlined into unicode_replace 
unicode_replace
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_replace
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_replace
gvn
                               
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_replace
gvn
                               
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_replace
gvn
                                     
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_replace
gvn
                                     
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_replace
12558
}
12559
12560
static PyObject *
12561
unicode_repr(PyObject *unicode)
12562
{
12563
    PyObject *repr;
12564
    Py_ssize_t isize;
12565
    Py_ssize_t osize, squote, dquote, i, o;
12566
    Py_UCS4 max, quote;
12567
    int ikind, okind, unchanged;
12568
    void *idata, *odata;
12569
12570
    if (PyUnicode_READY(unicode) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_repr
inline
        
_PyUnicode_Ready will not be inlined into unicode_repr 
unicode_repr
12571
        return NULL;
12572
12573
    isize = PyUnicode_GET_LENGTH(unicode);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_repr
12574
    idata = PyUnicode_DATA(unicode);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_repr
gvn
            
load eliminated by PRE 
unicode_repr
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_repr
12575
12576
    /* Compute length of output, quote characters, and
12577
       maximum character */
12578
    osize = 0;
12579
    max = 127;
12580
    squote = dquote = 0;
12581
    ikind = PyUnicode_KIND(unicode);
12582
    for (i = 0; i < isize; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_repr
loop-vectorize
    
loop not vectorized 
unicode_repr
12583
        Py_UCS4 ch = PyUnicode_READ(ikind, idata, i);
licm
                     
hosting trunc 
unicode_repr
licm
                     
hosting bitcast 
unicode_repr
12584
        Py_ssize_t incr = 1;
12585
        switch (ch) {
12586
        case '\'': squote++; break;
12587
        case '"':  dquote++; break;
12588
        case '\\': case '\t': case '\r': case '\n':
12589
            incr = 2;
12590
            break;
12591
        default:
12592
            /* Fast-path ASCII */
12593
            if (ch < ' ' || ch == 0x7f)
12594
                incr = 4; /* \xHH */
12595
            else if (ch < 0x7f)
12596
                ;
12597
            else if (Py_UNICODE_ISPRINTABLE(ch))
inline
                     
_PyUnicode_IsPrintable will not be inlined into unicode_repr because its definition is unavailable 
unicode_repr
12598
                max = ch > max ? ch : max;
12599
            else if (ch < 0x100)
12600
                incr = 4; /* \xHH */
12601
            else if (ch < 0x10000)
12602
                incr = 6; /* \uHHHH */
12603
            else
12604
                incr = 10; /* \uHHHHHHHH */
12605
        }
12606
        if (osize > PY_SSIZE_T_MAX - incr) {
12607
            PyErr_SetString(PyExc_OverflowError,
inline
            
PyErr_SetString will not be inlined into unicode_repr because its definition is unavailable 
unicode_repr
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_repr
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_repr
12608
                            "string is too long to generate repr");
12609
            return NULL;
12610
        }
12611
        osize += incr;
12612
    }
12613
12614
    quote = '\'';
12615
    unchanged = (osize == isize);
12616
    if (squote) {
12617
        unchanged = 0;
12618
        if (dquote)
12619
            /* Both squote and dquote present. Use squote,
12620
               and escape them */
12621
            osize += squote;
12622
        else
12623
            quote = '"';
12624
    }
12625
    osize += 2;   /* quotes */
12626
12627
    repr = PyUnicode_New(osize, max);
inline
           
PyUnicode_New too costly to inline (cost=460, threshold=250) 
unicode_repr
inline
           
PyUnicode_New will not be inlined into unicode_repr 
unicode_repr
12628
    if (repr == NULL)
12629
        return NULL;
12630
    okind = PyUnicode_KIND(repr);
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_repr
12631
    odata = PyUnicode_DATA(repr);
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_repr
12632
12633
    PyUnicode_WRITE(okind, odata, 0, quote);
12634
    PyUnicode_WRITE(okind, odata, osize-1, quote);
12635
    if (unchanged) {
12636
        _PyUnicode_FastCopyCharacters(repr, 1,
inline
        
_PyUnicode_FastCopyCharacters can be inlined into unicode_repr with cost=5 (threshold=375) 
unicode_repr
inline
        
_PyUnicode_FastCopyCharacters inlined into unicode_repr 
unicode_repr
12637
                                      unicode, 0,
12638
                                      isize);
12639
    }
12640
    else {
12641
        for (i = 0, o = 1; i < isize; i++) {
loop-vectorize
        
loop not vectorized 
unicode_repr
12642
            Py_UCS4 ch = PyUnicode_READ(ikind, idata, i);
licm
                         
hosting trunc 
unicode_repr
licm
                         
hosting bitcast 
unicode_repr
gvn
                         
load of type i16 not eliminated because it is clobbered by store 
unicode_repr
gvn
                         
load of type i16 not eliminated because it is clobbered by call 
unicode_repr
gvn
                         
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                         
load of type i32 not eliminated because it is clobbered by store 
unicode_repr
gvn
                         
load of type i32 not eliminated because it is clobbered by call 
unicode_repr
loop-vectorize
                         
loop not vectorized: loop contains a switch statement 
unicode_repr
12643
12644
            /* Escape quotes and backslashes */
12645
            if ((ch == quote) || (ch == '\\')) {
12646
                PyUnicode_WRITE(okind, odata, o++, '\\');
licm
                
hosting bitcast 
unicode_repr
12647
                PyUnicode_WRITE(okind, odata, o++, ch);
licm
                
hosting bitcast 
unicode_repr
12648
                continue;
12649
            }
12650
12651
            /* Map special whitespace to '\t', \n', '\r' */
12652
            if (ch == '\t') {
12653
                PyUnicode_WRITE(okind, odata, o++, '\\');
licm
                
hosting bitcast 
unicode_repr
12654
                PyUnicode_WRITE(okind, odata, o++, 't');
licm
                
hosting bitcast 
unicode_repr
12655
            }
12656
            else if (ch == '\n') {
12657
                PyUnicode_WRITE(okind, odata, o++, '\\');
licm
                
hosting bitcast 
unicode_repr
12658
                PyUnicode_WRITE(okind, odata, o++, 'n');
licm
                
hosting bitcast 
unicode_repr
12659
            }
12660
            else if (ch == '\r') {
12661
                PyUnicode_WRITE(okind, odata, o++, '\\');
licm
                
hosting bitcast 
unicode_repr
12662
                PyUnicode_WRITE(okind, odata, o++, 'r');
licm
                
hosting bitcast 
unicode_repr
12663
            }
12664
12665
            /* Map non-printable US ASCII to '\xhh' */
12666
            else if (ch < ' ' || ch == 0x7F) {
12667
                PyUnicode_WRITE(okind, odata, o++, '\\');
licm
                
hosting bitcast 
unicode_repr
12668
                PyUnicode_WRITE(okind, odata, o++, 'x');
licm
                
hosting bitcast 
unicode_repr
12669
                PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 4) & 0x000F]);
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                
hosting bitcast 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by call 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by call 
unicode_repr
gvn
                
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
12670
                PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[ch & 0x000F]);
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                
hosting bitcast 
unicode_repr
gvn
                
load of type i8* eliminated in favor of load 
unicode_repr
gvn
                
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                
load of type i8* not eliminated in favor of load because it is clobbered by store 
unicode_repr
12671
            }
12672
12673
            /* Copy ASCII characters as-is */
12674
            else if (ch < 0x7F) {
12675
                PyUnicode_WRITE(okind, odata, o++, ch);
licm
                
hosting bitcast 
unicode_repr
12676
            }
12677
12678
            /* Non-ASCII characters */
12679
            else {
12680
                /* Map Unicode whitespace and control characters
12681
                   (categories Z* and C* except ASCII space)
12682
                */
12683
                if (!Py_UNICODE_ISPRINTABLE(ch)) {
inline
                     
_PyUnicode_IsPrintable will not be inlined into unicode_repr because its definition is unavailable 
unicode_repr
12684
                    PyUnicode_WRITE(okind, odata, o++, '\\');
licm
                    
hosting bitcast 
unicode_repr
12685
                    /* Map 8-bit characters to '\xhh' */
12686
                    if (ch <= 0xff) {
12687
                        PyUnicode_WRITE(okind, odata, o++, 'x');
licm
                        
hosting bitcast 
unicode_repr
12688
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 4) & 0x000F]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
12689
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[ch & 0x000F]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* eliminated in favor of load 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated in favor of load because it is clobbered by store 
unicode_repr
12690
                    }
12691
                    /* Map 16-bit characters to '\uxxxx' */
12692
                    else if (ch <= 0xffff) {
12693
                        PyUnicode_WRITE(okind, odata, o++, 'u');
licm
                        
hosting bitcast 
unicode_repr
12694
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 12) & 0xF]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
12695
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 8) & 0xF]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* eliminated in favor of load 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated in favor of load because it is clobbered by store 
unicode_repr
12696
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 4) & 0xF]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* eliminated in favor of load 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
12697
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[ch & 0xF]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* eliminated in favor of load 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated in favor of load because it is clobbered by store 
unicode_repr
12698
                    }
12699
                    /* Map 21-bit characters to '\U00xxxxxx' */
12700
                    else {
12701
                        PyUnicode_WRITE(okind, odata, o++, 'U');
licm
                        
hosting bitcast 
unicode_repr
12702
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 28) & 0xF]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated because it is clobbered by call 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
12703
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 24) & 0xF]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* eliminated in favor of load 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated in favor of load because it is clobbered by store 
unicode_repr
12704
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 20) & 0xF]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* eliminated in favor of load 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
12705
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 16) & 0xF]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* eliminated in favor of load 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated in favor of load because it is clobbered by store 
unicode_repr
12706
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 12) & 0xF]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* eliminated in favor of load 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
12707
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 8) & 0xF]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* eliminated in favor of load 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated in favor of load because it is clobbered by store 
unicode_repr
12708
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 4) & 0xF]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* eliminated in favor of load 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated because it is clobbered by store 
unicode_repr
12709
                        PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[ch & 0xF]);
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_repr
licm
                        
hosting bitcast 
unicode_repr
gvn
                        
load of type i8* eliminated in favor of load 
unicode_repr
gvn
                        
load of type i8 not eliminated because it is clobbered by store 
unicode_repr
gvn
                        
load of type i8* not eliminated in favor of load because it is clobbered by store 
unicode_repr
12710
                    }
12711
                }
12712
                /* Copy characters as-is */
12713
                else {
12714
                    PyUnicode_WRITE(okind, odata, o++, ch);
licm
                    
hosting bitcast 
unicode_repr
12715
                }
12716
            }
12717
        }
12718
    }
12719
    /* Closing quote already added at the beginning */
12720
    assert(_PyUnicode_CheckConsistency(repr, 1));
12721
    return repr;
12722
}
12723
12724
PyDoc_STRVAR(rfind__doc__,
12725
             "S.rfind(sub[, start[, end]]) -> int\n\
12726
\n\
12727
Return the highest index in S where substring sub is found,\n\
12728
such that sub is contained within S[start:end].  Optional\n\
12729
arguments start and end are interpreted as in slice notation.\n\
12730
\n\
12731
Return -1 on failure.");
12732
12733
static PyObject *
12734
unicode_rfind(PyObject *self, PyObject *args)
12735
{
12736
    /* initialize variables to prevent gcc warning */
12737
    PyObject *substring = NULL;
12738
    Py_ssize_t start = 0;
12739
    Py_ssize_t end = 0;
12740
    Py_ssize_t result;
12741
12742
    if (!parse_args_finds_unicode("rfind", args, &substring, &start, &end))
inline
         
parse_args_finds_unicode can be inlined into unicode_rfind with cost=155 (threshold=325) 
unicode_rfind
inline
         
parse_args_finds_unicode inlined into unicode_rfind 
unicode_rfind
12743
        return NULL;
12744
12745
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_rfind
inline
        
_PyUnicode_Ready will not be inlined into unicode_rfind 
unicode_rfind
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_rfind
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_rfind
12746
        return NULL;
12747
12748
    result = any_find_slice(self, substring, start, end, -1);
inline
             
any_find_slice too costly to inline (cost=630, threshold=625) 
unicode_rfind
inline
             
any_find_slice will not be inlined into unicode_rfind 
unicode_rfind
gvn
                                  
load of type %struct._object* eliminated in favor of load 
unicode_rfind
gvn
                                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_rfind
gvn
                                                    
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_rfind
12749
12750
    if (result == -2)
12751
        return NULL;
12752
12753
    return PyLong_FromSsize_t(result);
inline
           
PyLong_FromSsize_t will not be inlined into unicode_rfind because its definition is unavailable 
unicode_rfind
12754
}
12755
12756
PyDoc_STRVAR(rindex__doc__,
12757
             "S.rindex(sub[, start[, end]]) -> int\n\
12758
\n\
12759
Like S.rfind() but raise ValueError when the substring is not found.");
12760
12761
static PyObject *
12762
unicode_rindex(PyObject *self, PyObject *args)
12763
{
12764
    /* initialize variables to prevent gcc warning */
12765
    PyObject *substring = NULL;
12766
    Py_ssize_t start = 0;
12767
    Py_ssize_t end = 0;
12768
    Py_ssize_t result;
12769
12770
    if (!parse_args_finds_unicode("rindex", args, &substring, &start, &end))
inline
         
parse_args_finds_unicode can be inlined into unicode_rindex with cost=-14845 (threshold=325) 
unicode_rindex
inline
         
parse_args_finds_unicode inlined into unicode_rindex 
unicode_rindex
12771
        return NULL;
12772
12773
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_rindex
inline
        
_PyUnicode_Ready will not be inlined into unicode_rindex 
unicode_rindex
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_rindex
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_rindex
12774
        return NULL;
12775
12776
    result = any_find_slice(self, substring, start, end, -1);
inline
             
any_find_slice too costly to inline (cost=630, threshold=625) 
unicode_rindex
inline
             
any_find_slice will not be inlined into unicode_rindex 
unicode_rindex
gvn
                                  
load of type %struct._object* eliminated in favor of load 
unicode_rindex
gvn
                                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_rindex
gvn
                                                    
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_rindex
12777
12778
    if (result == -2)
12779
        return NULL;
12780
12781
    if (result < 0) {
12782
        PyErr_SetString(PyExc_ValueError, "substring not found");
inline
        
PyErr_SetString will not be inlined into unicode_rindex because its definition is unavailable 
unicode_rindex
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_rindex
12783
        return NULL;
12784
    }
12785
12786
    return PyLong_FromSsize_t(result);
inline
           
PyLong_FromSsize_t will not be inlined into unicode_rindex because its definition is unavailable 
unicode_rindex
12787
}
12788
12789
PyDoc_STRVAR(rjust__doc__,
12790
             "S.rjust(width[, fillchar]) -> str\n\
12791
\n\
12792
Return S right-justified in a string of length width. Padding is\n\
12793
done using the specified fill character (default is a space).");
12794
12795
static PyObject *
12796
unicode_rjust(PyObject *self, PyObject *args)
12797
{
12798
    Py_ssize_t width;
12799
    Py_UCS4 fillchar = ' ';
12800
12801
    if (!PyArg_ParseTuple(args, "n|O&:rjust", &width, convert_uc, &fillchar))
inline
         
_PyArg_ParseTuple_SizeT will not be inlined into unicode_rjust because its definition is unavailable 
unicode_rjust
12802
        return NULL;
12803
12804
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_rjust
inline
        
_PyUnicode_Ready will not be inlined into unicode_rjust 
unicode_rjust
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_rjust
12805
        return NULL;
12806
12807
    if (PyUnicode_GET_LENGTH(self) >= width)
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_rjust
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_rjust
gvn
                                      
load of type i64 not eliminated because it is clobbered by call 
unicode_rjust
gvn
                                      
load of type i64 not eliminated because it is clobbered by call 
unicode_rjust
12808
        return unicode_result_unchanged(self);
inline
               
unicode_result_unchanged can be inlined into unicode_rjust with cost=90 (threshold=250) 
unicode_rjust
inline
               
unicode_result_unchanged inlined into unicode_rjust 
unicode_rjust
12809
12810
    return pad(self, width - PyUnicode_GET_LENGTH(self), 0, fillchar);
inline
           
pad too costly to inline (cost=495, threshold=250) 
unicode_rjust
inline
           
pad will not be inlined into unicode_rjust 
unicode_rjust
gvn
                                                            
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_rjust
gvn
                                                            
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_rjust
12811
}
12812
12813
PyObject *
12814
PyUnicode_Split(PyObject *s, PyObject *sep, Py_ssize_t maxsplit)
12815
{
12816
    if (ensure_unicode(s) < 0 || (sep != NULL && ensure_unicode(sep) < 0))
inline
        
ensure_unicode can be inlined into PyUnicode_Split with cost=95 (threshold=250) 
PyUnicode_Split
inline
        
ensure_unicode inlined into PyUnicode_Split 
PyUnicode_Split
inline
                                                 
ensure_unicode can be inlined into PyUnicode_Split with cost=95 (threshold=250) 
PyUnicode_Split
inline
                                                 
ensure_unicode inlined into PyUnicode_Split 
PyUnicode_Split
12817
        return NULL;
12818
12819
    return split(s, sep, maxsplit);
inline
           
split too costly to inline (cost=655, threshold=625) 
PyUnicode_Split
inline
           
split will not be inlined into PyUnicode_Split 
PyUnicode_Split
12820
}
12821
12822
PyDoc_STRVAR(split__doc__,
12823
             "S.split(sep=None, maxsplit=-1) -> list of strings\n\
12824
\n\
12825
Return a list of the words in S, using sep as the\n\
12826
delimiter string.  If maxsplit is given, at most maxsplit\n\
12827
splits are done. If sep is not specified or is None, any\n\
12828
whitespace string is a separator and empty strings are\n\
12829
removed from the result.");
12830
12831
static PyObject*
12832
unicode_split(PyObject *self, PyObject *args, PyObject *kwds)
12833
{
12834
    static char *kwlist[] = {"sep", "maxsplit", 0};
12835
    PyObject *substring = Py_None;
12836
    Py_ssize_t maxcount = -1;
12837
12838
    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|On:split",
inline
         
_PyArg_ParseTupleAndKeywords_SizeT will not be inlined into unicode_split because its definition is unavailable 
unicode_split
12839
                                     kwlist, &substring, &maxcount))
12840
        return NULL;
12841
12842
    if (substring == Py_None)
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_split
12843
        return split(self, NULL, maxcount);
inline
               
split too costly to inline (cost=630, threshold=625) 
unicode_split
inline
               
split will not be inlined into unicode_split 
unicode_split
gvn
                                 
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_split
12844
12845
    if (PyUnicode_Check(substring))
12846
        return split(self, substring, maxcount);
inline
               
split too costly to inline (cost=655, threshold=625) 
unicode_split
inline
               
split will not be inlined into unicode_split 
unicode_split
gvn
                                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_split
12847
12848
    PyErr_Format(PyExc_TypeError,
inline
    
PyErr_Format will not be inlined into unicode_split because its definition is unavailable 
unicode_split
gvn
                 
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_split
12849
                 "must be str or None, not %.100s",
12850
                 Py_TYPE(substring)->tp_name);
12851
    return NULL;
12852
}
12853
12854
PyObject *
12855
PyUnicode_Partition(PyObject *str_obj, PyObject *sep_obj)
12856
{
12857
    PyObject* out;
12858
    int kind1, kind2;
12859
    void *buf1, *buf2;
12860
    Py_ssize_t len1, len2;
12861
12862
    if (ensure_unicode(str_obj) < 0 || ensure_unicode(sep_obj) < 0)
inline
        
ensure_unicode can be inlined into PyUnicode_Partition with cost=95 (threshold=250) 
PyUnicode_Partition
inline
        
ensure_unicode inlined into PyUnicode_Partition 
PyUnicode_Partition
inline
                                       
ensure_unicode can be inlined into PyUnicode_Partition with cost=95 (threshold=250) 
PyUnicode_Partition
inline
                                       
ensure_unicode inlined into PyUnicode_Partition 
PyUnicode_Partition
12863
        return NULL;
12864
12865
    kind1 = PyUnicode_KIND(str_obj);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Partition
12866
    kind2 = PyUnicode_KIND(sep_obj);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Partition
gvn
            
load eliminated by PRE 
PyUnicode_Partition
12867
    len1 = PyUnicode_GET_LENGTH(str_obj);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Partition
12868
    len2 = PyUnicode_GET_LENGTH(sep_obj);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Partition
12869
    if (kind1 < kind2 || len1 < len2) {
12870
        _Py_INCREF_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_Partition
inline
        
PyUnicode_New will not be inlined into PyUnicode_Partition 
PyUnicode_Partition
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Partition
12871
        if (!unicode_empty)
12872
            out = NULL;
12873
        else {
12874
            out = PyTuple_Pack(3, str_obj, unicode_empty, unicode_empty);
inline
                  
PyTuple_Pack will not be inlined into PyUnicode_Partition because its definition is unavailable 
PyUnicode_Partition
12875
            Py_DECREF(unicode_empty);
gvn
            
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Partition
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Partition
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Partition
12876
        }
12877
        return out;
12878
    }
12879
    buf1 = PyUnicode_DATA(str_obj);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Partition
12880
    buf2 = PyUnicode_DATA(sep_obj);
gvn
           
load of type i32 eliminated in favor of phi 
PyUnicode_Partition
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Partition
12881
    if (kind2 != kind1) {
12882
        buf2 = _PyUnicode_AsKind(sep_obj, kind1);
inline
               
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
PyUnicode_Partition
inline
               
_PyUnicode_AsKind will not be inlined into PyUnicode_Partition 
PyUnicode_Partition
12883
        if (!buf2)
12884
            return NULL;
12885
    }
12886
12887
    switch (kind1) {
12888
    case PyUnicode_1BYTE_KIND:
12889
        if (PyUnicode_IS_ASCII(str_obj) && PyUnicode_IS_ASCII(sep_obj))
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Partition
gvn
                                           
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Partition
12890
            out = asciilib_partition(str_obj, buf1, len1, sep_obj, buf2, len2);
inline
                  
asciilib_partition can be inlined into PyUnicode_Partition with cost=-14200 (threshold=325) 
PyUnicode_Partition
inline
                  
asciilib_partition inlined into PyUnicode_Partition 
PyUnicode_Partition
12891
        else
12892
            out = ucs1lib_partition(str_obj, buf1, len1, sep_obj, buf2, len2);
inline
                  
ucs1lib_partition can be inlined into PyUnicode_Partition with cost=-14630 (threshold=325) 
PyUnicode_Partition
inline
                  
ucs1lib_partition inlined into PyUnicode_Partition 
PyUnicode_Partition
12893
        break;
12894
    case PyUnicode_2BYTE_KIND:
12895
        out = ucs2lib_partition(str_obj, buf1, len1, sep_obj, buf2, len2);
inline
              
ucs2lib_partition can be inlined into PyUnicode_Partition with cost=-14630 (threshold=325) 
PyUnicode_Partition
inline
              
ucs2lib_partition inlined into PyUnicode_Partition 
PyUnicode_Partition
12896
        break;
12897
    case PyUnicode_4BYTE_KIND:
12898
        out = ucs4lib_partition(str_obj, buf1, len1, sep_obj, buf2, len2);
inline
              
ucs4lib_partition can be inlined into PyUnicode_Partition with cost=-14630 (threshold=325) 
PyUnicode_Partition
inline
              
ucs4lib_partition inlined into PyUnicode_Partition 
PyUnicode_Partition
12899
        break;
12900
    default:
12901
        assert(0);
12902
        out = 0;
12903
    }
12904
12905
    if (kind2 != kind1)
12906
        PyMem_Free(buf2);
inline
        
PyMem_Free will not be inlined into PyUnicode_Partition because its definition is unavailable 
PyUnicode_Partition
12907
12908
    return out;
12909
}
12910
12911
12912
PyObject *
12913
PyUnicode_RPartition(PyObject *str_obj, PyObject *sep_obj)
12914
{
12915
    PyObject* out;
12916
    int kind1, kind2;
12917
    void *buf1, *buf2;
12918
    Py_ssize_t len1, len2;
12919
12920
    if (ensure_unicode(str_obj) < 0 || ensure_unicode(sep_obj) < 0)
inline
        
ensure_unicode can be inlined into PyUnicode_RPartition with cost=95 (threshold=250) 
PyUnicode_RPartition
inline
        
ensure_unicode inlined into PyUnicode_RPartition 
PyUnicode_RPartition
inline
                                       
ensure_unicode can be inlined into PyUnicode_RPartition with cost=95 (threshold=250) 
PyUnicode_RPartition
inline
                                       
ensure_unicode inlined into PyUnicode_RPartition 
PyUnicode_RPartition
12921
        return NULL;
12922
12923
    kind1 = PyUnicode_KIND(str_obj);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_RPartition
12924
    kind2 = PyUnicode_KIND(sep_obj);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_RPartition
gvn
            
load eliminated by PRE 
PyUnicode_RPartition
12925
    len1 = PyUnicode_GET_LENGTH(str_obj);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_RPartition
12926
    len2 = PyUnicode_GET_LENGTH(sep_obj);
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_RPartition
12927
    if (kind1 < kind2 || len1 < len2) {
12928
        _Py_INCREF_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
PyUnicode_RPartition
inline
        
PyUnicode_New will not be inlined into PyUnicode_RPartition 
PyUnicode_RPartition
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_RPartition
12929
        if (!unicode_empty)
12930
            out = NULL;
12931
        else {
12932
            out = PyTuple_Pack(3, unicode_empty, unicode_empty, str_obj);
inline
                  
PyTuple_Pack will not be inlined into PyUnicode_RPartition because its definition is unavailable 
PyUnicode_RPartition
12933
            Py_DECREF(unicode_empty);
gvn
            
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
PyUnicode_RPartition
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_RPartition
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_RPartition
12934
        }
12935
        return out;
12936
    }
12937
    buf1 = PyUnicode_DATA(str_obj);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_RPartition
12938
    buf2 = PyUnicode_DATA(sep_obj);
gvn
           
load of type i32 eliminated in favor of phi 
PyUnicode_RPartition
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_RPartition
12939
    if (kind2 != kind1) {
12940
        buf2 = _PyUnicode_AsKind(sep_obj, kind1);
inline
               
_PyUnicode_AsKind too costly to inline (cost=630, threshold=625) 
PyUnicode_RPartition
inline
               
_PyUnicode_AsKind will not be inlined into PyUnicode_RPartition 
PyUnicode_RPartition
12941
        if (!buf2)
12942
            return NULL;
12943
    }
12944
12945
    switch (kind1) {
12946
    case PyUnicode_1BYTE_KIND:
12947
        if (PyUnicode_IS_ASCII(str_obj) && PyUnicode_IS_ASCII(sep_obj))
gvn
            
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_RPartition
gvn
                                           
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_RPartition
12948
            out = asciilib_rpartition(str_obj, buf1, len1, sep_obj, buf2, len2);
inline
                  
asciilib_rpartition can be inlined into PyUnicode_RPartition with cost=-14200 (threshold=325) 
PyUnicode_RPartition
inline
                  
asciilib_rpartition inlined into PyUnicode_RPartition 
PyUnicode_RPartition
12949
        else
12950
            out = ucs1lib_rpartition(str_obj, buf1, len1, sep_obj, buf2, len2);
inline
                  
ucs1lib_rpartition can be inlined into PyUnicode_RPartition with cost=-14630 (threshold=325) 
PyUnicode_RPartition
inline
                  
ucs1lib_rpartition inlined into PyUnicode_RPartition 
PyUnicode_RPartition
12951
        break;
12952
    case PyUnicode_2BYTE_KIND:
12953
        out = ucs2lib_rpartition(str_obj, buf1, len1, sep_obj, buf2, len2);
inline
              
ucs2lib_rpartition can be inlined into PyUnicode_RPartition with cost=-14630 (threshold=325) 
PyUnicode_RPartition
inline
              
ucs2lib_rpartition inlined into PyUnicode_RPartition 
PyUnicode_RPartition
12954
        break;
12955
    case PyUnicode_4BYTE_KIND:
12956
        out = ucs4lib_rpartition(str_obj, buf1, len1, sep_obj, buf2, len2);
inline
              
ucs4lib_rpartition can be inlined into PyUnicode_RPartition with cost=-14630 (threshold=325) 
PyUnicode_RPartition
inline
              
ucs4lib_rpartition inlined into PyUnicode_RPartition 
PyUnicode_RPartition
12957
        break;
12958
    default:
12959
        assert(0);
12960
        out = 0;
12961
    }
12962
12963
    if (kind2 != kind1)
12964
        PyMem_Free(buf2);
inline
        
PyMem_Free will not be inlined into PyUnicode_RPartition because its definition is unavailable 
PyUnicode_RPartition
12965
12966
    return out;
12967
}
12968
12969
PyDoc_STRVAR(partition__doc__,
12970
             "S.partition(sep) -> (head, sep, tail)\n\
12971
\n\
12972
Search for the separator sep in S, and return the part before it,\n\
12973
the separator itself, and the part after it.  If the separator is not\n\
12974
found, return S and two empty strings.");
12975
12976
static PyObject*
12977
unicode_partition(PyObject *self, PyObject *separator)
12978
{
12979
    return PyUnicode_Partition(self, separator);
inline
           
PyUnicode_Partition too costly to inline (cost=635, threshold=625) 
unicode_partition
inline
           
PyUnicode_Partition will not be inlined into unicode_partition 
unicode_partition
12980
}
12981
12982
PyDoc_STRVAR(rpartition__doc__,
12983
             "S.rpartition(sep) -> (head, sep, tail)\n\
12984
\n\
12985
Search for the separator sep in S, starting at the end of S, and return\n\
12986
the part before it, the separator itself, and the part after it.  If the\n\
12987
separator is not found, return two empty strings and S.");
12988
12989
static PyObject*
12990
unicode_rpartition(PyObject *self, PyObject *separator)
12991
{
12992
    return PyUnicode_RPartition(self, separator);
inline
           
PyUnicode_RPartition too costly to inline (cost=635, threshold=625) 
unicode_rpartition
inline
           
PyUnicode_RPartition will not be inlined into unicode_rpartition 
unicode_rpartition
12993
}
12994
12995
PyObject *
12996
PyUnicode_RSplit(PyObject *s, PyObject *sep, Py_ssize_t maxsplit)
12997
{
12998
    if (ensure_unicode(s) < 0 || (sep != NULL && ensure_unicode(sep) < 0))
inline
        
ensure_unicode can be inlined into PyUnicode_RSplit with cost=95 (threshold=250) 
PyUnicode_RSplit
inline
        
ensure_unicode inlined into PyUnicode_RSplit 
PyUnicode_RSplit
inline
                                                 
ensure_unicode can be inlined into PyUnicode_RSplit with cost=95 (threshold=250) 
PyUnicode_RSplit
inline
                                                 
ensure_unicode inlined into PyUnicode_RSplit 
PyUnicode_RSplit
12999
        return NULL;
13000
13001
    return rsplit(s, sep, maxsplit);
inline
           
rsplit too costly to inline (cost=655, threshold=625) 
PyUnicode_RSplit
inline
           
rsplit will not be inlined into PyUnicode_RSplit 
PyUnicode_RSplit
13002
}
13003
13004
PyDoc_STRVAR(rsplit__doc__,
13005
             "S.rsplit(sep=None, maxsplit=-1) -> list of strings\n\
13006
\n\
13007
Return a list of the words in S, using sep as the\n\
13008
delimiter string, starting at the end of the string and\n\
13009
working to the front.  If maxsplit is given, at most maxsplit\n\
13010
splits are done. If sep is not specified, any whitespace string\n\
13011
is a separator.");
13012
13013
static PyObject*
13014
unicode_rsplit(PyObject *self, PyObject *args, PyObject *kwds)
13015
{
13016
    static char *kwlist[] = {"sep", "maxsplit", 0};
13017
    PyObject *substring = Py_None;
13018
    Py_ssize_t maxcount = -1;
13019
13020
    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|On:rsplit",
inline
         
_PyArg_ParseTupleAndKeywords_SizeT will not be inlined into unicode_rsplit because its definition is unavailable 
unicode_rsplit
13021
                                     kwlist, &substring, &maxcount))
13022
        return NULL;
13023
13024
    if (substring == Py_None)
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_rsplit
13025
        return rsplit(self, NULL, maxcount);
inline
               
rsplit too costly to inline (cost=630, threshold=625) 
unicode_rsplit
inline
               
rsplit will not be inlined into unicode_rsplit 
unicode_rsplit
gvn
                                  
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_rsplit
13026
13027
    if (PyUnicode_Check(substring))
13028
        return rsplit(self, substring, maxcount);
inline
               
rsplit too costly to inline (cost=655, threshold=625) 
unicode_rsplit
inline
               
rsplit will not be inlined into unicode_rsplit 
unicode_rsplit
gvn
                                       
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_rsplit
13029
13030
    PyErr_Format(PyExc_TypeError,
inline
    
PyErr_Format will not be inlined into unicode_rsplit because its definition is unavailable 
unicode_rsplit
gvn
                 
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_rsplit
13031
                 "must be str or None, not %.100s",
13032
                 Py_TYPE(substring)->tp_name);
13033
    return NULL;
13034
}
13035
13036
PyDoc_STRVAR(splitlines__doc__,
13037
             "S.splitlines([keepends]) -> list of strings\n\
13038
\n\
13039
Return a list of the lines in S, breaking at line boundaries.\n\
13040
Line breaks are not included in the resulting list unless keepends\n\
13041
is given and true.");
13042
13043
static PyObject*
13044
unicode_splitlines(PyObject *self, PyObject *args, PyObject *kwds)
13045
{
13046
    static char *kwlist[] = {"keepends", 0};
13047
    int keepends = 0;
13048
13049
    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|i:splitlines",
inline
         
_PyArg_ParseTupleAndKeywords_SizeT will not be inlined into unicode_splitlines because its definition is unavailable 
unicode_splitlines
13050
                                     kwlist, &keepends))
13051
        return NULL;
13052
13053
    return PyUnicode_Splitlines(self, keepends);
inline
           
PyUnicode_Splitlines too costly to inline (cost=630, threshold=625) 
unicode_splitlines
inline
           
PyUnicode_Splitlines will not be inlined into unicode_splitlines 
unicode_splitlines
gvn
                                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_splitlines
13054
}
13055
13056
static
13057
PyObject *unicode_str(PyObject *self)
13058
{
13059
    return unicode_result_unchanged(self);
inline
           
unicode_result_unchanged can be inlined into unicode_str with cost=90 (threshold=250) 
unicode_str
inline
           
unicode_result_unchanged inlined into unicode_str 
unicode_str
13060
}
13061
13062
PyDoc_STRVAR(swapcase__doc__,
13063
             "S.swapcase() -> str\n\
13064
\n\
13065
Return a copy of S with uppercase characters converted to lowercase\n\
13066
and vice versa.");
13067
13068
static PyObject*
13069
unicode_swapcase(PyObject *self)
13070
{
13071
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_swapcase
inline
        
_PyUnicode_Ready will not be inlined into unicode_swapcase 
unicode_swapcase
13072
        return NULL;
13073
    return case_operation(self, do_swapcase);
inline
           
case_operation too costly to inline (cost=580, threshold=250) 
unicode_swapcase
inline
           
case_operation will not be inlined into unicode_swapcase 
unicode_swapcase
13074
}
13075
13076
/*[clinic input]
13077
13078
@staticmethod
13079
str.maketrans as unicode_maketrans
13080
13081
  x: object
13082
13083
  y: unicode=NULL
13084
13085
  z: unicode=NULL
13086
13087
  /
13088
13089
Return a translation table usable for str.translate().
13090
13091
If there is only one argument, it must be a dictionary mapping Unicode
13092
ordinals (integers) or characters to Unicode ordinals, strings or None.
13093
Character keys will be then converted to ordinals.
13094
If there are two arguments, they must be strings of equal length, and
13095
in the resulting dictionary, each character in x will be mapped to the
13096
character at the same position in y. If there is a third argument, it
13097
must be a string, whose characters will be mapped to None in the result.
13098
[clinic start generated code]*/
13099
13100
static PyObject *
13101
unicode_maketrans_impl(PyObject *x, PyObject *y, PyObject *z)
13102
/*[clinic end generated code: output=a925c89452bd5881 input=7bfbf529a293c6c5]*/
13103
{
13104
    PyObject *new = NULL, *key, *value;
13105
    Py_ssize_t i = 0;
13106
    int res;
13107
13108
    new = PyDict_New();
inline
          
PyDict_New will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
13109
    if (!new)
13110
        return NULL;
13111
    if (y != NULL) {
13112
        int x_kind, y_kind, z_kind;
13113
        void *x_data, *y_data, *z_data;
13114
13115
        /* x must be a string too, of equal length */
13116
        if (!PyUnicode_Check(x)) {
gvn
             
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
             
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
13117
            PyErr_SetString(PyExc_TypeError, "first maketrans argument must "
inline
            
PyErr_SetString will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans
13118
                            "be a string if there is a second argument");
13119
            goto err;
13120
        }
13121
        if (PyUnicode_GET_LENGTH(x) != PyUnicode_GET_LENGTH(y)) {
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
13122
            PyErr_SetString(PyExc_ValueError, "the first two maketrans "
inline
            
PyErr_SetString will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans
13123
                            "arguments must have equal length");
13124
            goto err;
13125
        }
13126
        /* create entries for translating chars in x to those in y */
13127
        x_kind = PyUnicode_KIND(x);
gvn
                 
load of type i32 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                 
load of type i32 not eliminated because it is clobbered by call 
unicode_maketrans
13128
        y_kind = PyUnicode_KIND(y);
gvn
                 
load of type i32 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                 
load of type i32 not eliminated because it is clobbered by call 
unicode_maketrans
13129
        x_data = PyUnicode_DATA(x);
gvn
                 
load of type i8* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                 
load of type i8* not eliminated because it is clobbered by call 
unicode_maketrans
13130
        y_data = PyUnicode_DATA(y);
gvn
                 
load of type i8* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                 
load of type i8* not eliminated because it is clobbered by call 
unicode_maketrans
13131
        for (i = 0; i < PyUnicode_GET_LENGTH(x); i++) {
licm
                                                  
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans_impl
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans_impl
gvn
                        
load of type i64 eliminated in favor of load 
unicode_maketrans_impl
gvn
                                                  
load of type i64 not eliminated because it is clobbered by store 
unicode_maketrans_impl
gvn
                        
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_maketrans_impl
gvn
                        
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_maketrans_impl
gvn
                        
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_maketrans_impl
licm
                                                  
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans
gvn
                                                  
load of type i64 not eliminated because it is clobbered by store 
unicode_maketrans
gvn
                                                  
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                        
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_maketrans
gvn
                        
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_maketrans
gvn
                        
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_maketrans
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_maketrans
loop-vectorize
        
loop not vectorized 
unicode_maketrans
13132
            key = PyLong_FromLong(PyUnicode_READ(x_kind, x_data, i));
inline
                  
PyLong_FromLong will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
licm
                                  
hosting trunc 
unicode_maketrans_impl
licm
                                  
hosting bitcast 
unicode_maketrans_impl
gvn
                                  
load of type i8 not eliminated because it is clobbered by store 
unicode_maketrans_impl
licm
                                  
hosting icmp 
unicode_maketrans_impl
gvn
                                  
load of type i8 not eliminated because it is clobbered by store 
unicode_maketrans
13133
            if (!key)
13134
                goto err;
13135
            value = PyLong_FromLong(PyUnicode_READ(y_kind, y_data, i));
inline
                    
PyLong_FromLong will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
licm
                                    
hosting icmp 
unicode_maketrans_impl
licm
                                    
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans_impl
licm
                                    
hosting bitcast 
unicode_maketrans_impl
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                                    
load of type i16 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                                    
load of type i8 not eliminated because it is clobbered by store 
unicode_maketrans_impl
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                                    
load of type i16 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                                    
load of type i8 not eliminated because it is clobbered by store 
unicode_maketrans
13136
            if (!value) {
13137
                Py_DECREF(key);
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
13138
                goto err;
13139
            }
13140
            res = PyDict_SetItem(new, key, value);
inline
                  
PyDict_SetItem will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
licm
                                      
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans_impl
gvn
                                      
load of type %struct._object* eliminated in favor of call 
unicode_maketrans_impl
13141
            Py_DECREF(key);
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans_impl
gvn
            
load of type %struct._object* eliminated in favor of call 
unicode_maketrans_impl
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
13142
            Py_DECREF(value);
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans_impl
gvn
            
load of type %struct._object* eliminated in favor of call 
unicode_maketrans_impl
gvn
            
load of type i64 not eliminated because it is clobbered by store 
unicode_maketrans_impl
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
            
load of type i64 not eliminated because it is clobbered by store 
unicode_maketrans
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
13143
            if (res < 0)
13144
                goto err;
13145
        }
13146
        /* create entries for deleting chars in z */
13147
        if (z != NULL) {
13148
            z_kind = PyUnicode_KIND(z);
gvn
                     
load of type i32 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                     
load of type i32 not eliminated because it is clobbered by store 
unicode_maketrans_impl
gvn
                     
load of type i32 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                     
load of type i32 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                     
load of type i32 not eliminated because it is clobbered by store 
unicode_maketrans
gvn
                     
load of type i32 not eliminated because it is clobbered by call 
unicode_maketrans
13149
            z_data = PyUnicode_DATA(z);
gvn
                     
load of type i8* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                     
load of type i8* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                     
load of type i8* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                     
load of type i8* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                     
load of type i8* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                     
load of type i8* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                     
load of type i8* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                     
load of type i8* not eliminated because it is clobbered by call 
unicode_maketrans
13150
            for (i = 0; i < PyUnicode_GET_LENGTH(z); i++) {
licm
                                                      
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans_impl
licm
                            
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans_impl
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                                                      
load of type i64 not eliminated in favor of store because it is clobbered by store 
unicode_maketrans_impl
gvn
                            
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_maketrans_impl
gvn
                            
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_maketrans_impl
licm
                                                      
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans
licm
                            
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                                                      
load of type i64 not eliminated in favor of store because it is clobbered by store 
unicode_maketrans
gvn
                                                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_maketrans
gvn
                            
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_maketrans
gvn
                            
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_maketrans
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_maketrans
loop-vectorize
            
loop not vectorized 
unicode_maketrans
13151
                key = PyLong_FromLong(PyUnicode_READ(z_kind, z_data, i));
inline
                      
PyLong_FromLong will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
licm
                                      
hosting trunc 
unicode_maketrans_impl
licm
                                      
hosting bitcast 
unicode_maketrans_impl
gvn
                                      
load of type i8 not eliminated because it is clobbered by store 
unicode_maketrans_impl
licm
                    
Moving accesses to memory location out of the loop 
unicode_maketrans_impl
gvn
                                      
load of type i8 not eliminated because it is clobbered by store 
unicode_maketrans
13152
                if (!key)
13153
                    goto err;
13154
                res = PyDict_SetItem(new, key, Py_None);
inline
                      
PyDict_SetItem will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
13155
                Py_DECREF(key);
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans_impl
gvn
                
load of type %struct._object* eliminated in favor of call 
unicode_maketrans_impl
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
13156
                if (res < 0)
13157
                    goto err;
13158
            }
13159
        }
13160
    } else {
13161
        int kind;
13162
        void *data;
13163
13164
        /* x must be a dict */
13165
        if (!PyDict_CheckExact(x)) {
13166
            PyErr_SetString(PyExc_TypeError, "if you give only one argument "
inline
            
PyErr_SetString will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans
13167
                            "to maketrans it must be a dict");
13168
            goto err;
13169
        }
13170
        /* copy entries into the new dict, converting string keys to int keys */
13171
        while (PyDict_Next(x, &i, &key, &value)) {
inline
               
PyDict_Next will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_maketrans
loop-vectorize
        
loop not vectorized 
unicode_maketrans
13172
            if (PyUnicode_Check(key)) {
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans_impl
gvn
                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans_impl
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans
gvn
                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans
13173
                /* convert string keys to integer keys */
13174
                PyObject *newkey;
13175
                if (PyUnicode_GET_LENGTH(key) != 1) {
13176
                    PyErr_SetString(PyExc_ValueError, "string keys in translate "
inline
                    
PyErr_SetString will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans
13177
                                    "table must be of length 1");
13178
                    goto err;
13179
                }
13180
                kind = PyUnicode_KIND(key);
13181
                data = PyUnicode_DATA(key);
13182
                newkey = PyLong_FromLong(PyUnicode_READ(kind, data, 0));
inline
                         
PyLong_FromLong will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
13183
                if (!newkey)
13184
                    goto err;
13185
                res = PyDict_SetItem(new, newkey, value);
inline
                      
PyDict_SetItem will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
licm
                                                  
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans_impl
gvn
                                                  
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans_impl
licm
                                                  
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans
gvn
                                                  
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans
13186
                Py_DECREF(newkey);
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
                
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
13187
                if (res < 0)
13188
                    goto err;
13189
            } else if (PyLong_Check(key)) {
13190
                /* just keep integer keys */
13191
                if (PyDict_SetItem(new, key, value) < 0)
inline
                    
PyDict_SetItem will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
licm
                                             
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans_impl
gvn
                                             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans_impl
licm
                                             
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_maketrans
gvn
                                             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans
13192
                    goto err;
13193
            } else {
13194
                PyErr_SetString(PyExc_TypeError, "keys in translate table must "
inline
                
PyErr_SetString will not be inlined into unicode_maketrans_impl because its definition is unavailable 
unicode_maketrans_impl
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_maketrans
13195
                                "be strings or integers");
13196
                goto err;
13197
            }
13198
        }
13199
    }
13200
    return new;
13201
  err:
13202
    Py_DECREF(new);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans_impl
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_maketrans
13203
    return NULL;
13204
}
13205
13206
PyDoc_STRVAR(translate__doc__,
13207
             "S.translate(table) -> str\n\
13208
\n\
13209
Return a copy of the string S in which each character has been mapped\n\
13210
through the given translation table. The table must implement\n\
13211
lookup/indexing via __getitem__, for instance a dictionary or list,\n\
13212
mapping Unicode ordinals to Unicode ordinals, strings, or None. If\n\
13213
this operation raises LookupError, the character is left untouched.\n\
13214
Characters mapped to None are deleted.");
13215
13216
static PyObject*
13217
unicode_translate(PyObject *self, PyObject *table)
13218
{
13219
    return _PyUnicode_TranslateCharmap(self, table, "ignore");
inline
           
_PyUnicode_TranslateCharmap too costly to inline (cost=635, threshold=625) 
unicode_translate
inline
           
_PyUnicode_TranslateCharmap will not be inlined into unicode_translate 
unicode_translate
13220
}
13221
13222
PyDoc_STRVAR(upper__doc__,
13223
             "S.upper() -> str\n\
13224
\n\
13225
Return a copy of S converted to uppercase.");
13226
13227
static PyObject*
13228
unicode_upper(PyObject *self)
13229
{
13230
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_upper
inline
        
_PyUnicode_Ready will not be inlined into unicode_upper 
unicode_upper
13231
        return NULL;
13232
    if (PyUnicode_IS_ASCII(self))
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_upper
gvn
        
load eliminated by PRE 
unicode_upper
13233
        return ascii_upper_or_lower(self, 0);
inline
               
ascii_upper_or_lower can be inlined into unicode_upper with cost=-14860 (threshold=250) 
unicode_upper
inline
               
ascii_upper_or_lower inlined into unicode_upper 
unicode_upper
13234
    return case_operation(self, do_upper);
inline
           
case_operation too costly to inline (cost=435, threshold=250) 
unicode_upper
inline
           
case_operation will not be inlined into unicode_upper 
unicode_upper
13235
}
13236
13237
PyDoc_STRVAR(zfill__doc__,
13238
             "S.zfill(width) -> str\n\
13239
\n\
13240
Pad a numeric string S with zeros on the left, to fill a field\n\
13241
of the specified width. The string S is never truncated.");
13242
13243
static PyObject *
13244
unicode_zfill(PyObject *self, PyObject *args)
13245
{
13246
    Py_ssize_t fill;
13247
    PyObject *u;
13248
    Py_ssize_t width;
13249
    int kind;
13250
    void *data;
13251
    Py_UCS4 chr;
13252
13253
    if (!PyArg_ParseTuple(args, "n:zfill", &width))
inline
         
_PyArg_ParseTuple_SizeT will not be inlined into unicode_zfill because its definition is unavailable 
unicode_zfill
13254
        return NULL;
13255
13256
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_zfill
inline
        
_PyUnicode_Ready will not be inlined into unicode_zfill 
unicode_zfill
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_zfill
13257
        return NULL;
13258
13259
    if (PyUnicode_GET_LENGTH(self) >= width)
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_zfill
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_zfill
gvn
                                      
load of type i64 not eliminated because it is clobbered by call 
unicode_zfill
gvn
                                      
load of type i64 not eliminated because it is clobbered by call 
unicode_zfill
13260
        return unicode_result_unchanged(self);
inline
               
unicode_result_unchanged can be inlined into unicode_zfill with cost=-14910 (threshold=250) 
unicode_zfill
inline
               
unicode_result_unchanged inlined into unicode_zfill 
unicode_zfill
13261
13262
    fill = width - PyUnicode_GET_LENGTH(self);
13263
13264
    u = pad(self, fill, 0, '0');
inline
        
pad too costly to inline (cost=495, threshold=250) 
unicode_zfill
inline
        
pad will not be inlined into unicode_zfill 
unicode_zfill
13265
13266
    if (u == NULL)
13267
        return NULL;
13268
13269
    kind = PyUnicode_KIND(u);
gvn
           
load of type i32 not eliminated because it is clobbered by call 
unicode_zfill
13270
    data = PyUnicode_DATA(u);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_zfill
13271
    chr = PyUnicode_READ(kind, data, fill);
13272
13273
    if (chr == '+' || chr == '-') {
13274
        /* move sign to beginning of string */
13275
        PyUnicode_WRITE(kind, data, 0, chr);
13276
        PyUnicode_WRITE(kind, data, fill, '0');
13277
    }
13278
13279
    assert(_PyUnicode_CheckConsistency(u, 1));
13280
    return u;
13281
}
13282
13283
#if 0
13284
static PyObject *
13285
unicode__decimal2ascii(PyObject *self)
13286
{
13287
    return PyUnicode_TransformDecimalAndSpaceToASCII(self);
13288
}
13289
#endif
13290
13291
PyDoc_STRVAR(startswith__doc__,
13292
             "S.startswith(prefix[, start[, end]]) -> bool\n\
13293
\n\
13294
Return True if S starts with the specified prefix, False otherwise.\n\
13295
With optional start, test S beginning at that position.\n\
13296
With optional end, stop comparing S at that position.\n\
13297
prefix can also be a tuple of strings to try.");
13298
13299
static PyObject *
13300
unicode_startswith(PyObject *self,
13301
                   PyObject *args)
13302
{
13303
    PyObject *subobj;
13304
    PyObject *substring;
13305
    Py_ssize_t start = 0;
13306
    Py_ssize_t end = PY_SSIZE_T_MAX;
13307
    int result;
13308
13309
    if (!stringlib_parse_args_finds("startswith", args, &subobj, &start, &end))
inline
         
stringlib_parse_args_finds too costly to inline (cost=330, threshold=325) 
unicode_startswith
inline
         
stringlib_parse_args_finds will not be inlined into unicode_startswith 
unicode_startswith
13310
        return NULL;
13311
    if (PyTuple_Check(subobj)) {
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_startswith
13312
        Py_ssize_t i;
13313
        for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) {
licm
                        
hosting load 
unicode_startswith
licm
                        
hosting getelementptr 
unicode_startswith
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_startswith
gvn
                        
load of type %struct._object* eliminated in favor of load 
unicode_startswith
gvn
                        
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_startswith
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_startswith
loop-vectorize
        
loop not vectorized 
unicode_startswith
13314
            substring = PyTuple_GET_ITEM(subobj, i);
licm
                        
hosting getelementptr 
unicode_startswith
licm
                        
hosting bitcast 
unicode_startswith
13315
            if (!PyUnicode_Check(substring)) {
13316
                PyErr_Format(PyExc_TypeError,
inline
                
PyErr_Format will not be inlined into unicode_startswith because its definition is unavailable 
unicode_startswith
gvn
                             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_startswith
gvn
                             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_startswith
13317
                             "tuple for startswith must only contain str, "
13318
                             "not %.100s",
13319
                             Py_TYPE(substring)->tp_name);
13320
                return NULL;
13321
            }
13322
            result = tailmatch(self, substring, start, end, -1);
inline
                     
tailmatch too costly to inline (cost=630, threshold=625) 
unicode_startswith
inline
                     
tailmatch will not be inlined into unicode_startswith 
unicode_startswith
licm
                                                
hosting load 
unicode_startswith
licm
                                                       
hosting load 
unicode_startswith
13323
            if (result == -1)
13324
                return NULL;
13325
            if (result) {
13326
                Py_RETURN_TRUE;
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_startswith
13327
            }
13328
        }
13329
        /* nothing matched */
13330
        Py_RETURN_FALSE;
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_startswith
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_startswith
13331
    }
13332
    if (!PyUnicode_Check(subobj)) {
13333
        PyErr_Format(PyExc_TypeError,
inline
        
PyErr_Format will not be inlined into unicode_startswith because its definition is unavailable 
unicode_startswith
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_startswith
13334
                     "startswith first arg must be str or "
13335
                     "a tuple of str, not %.100s", Py_TYPE(subobj)->tp_name);
13336
        return NULL;
13337
    }
13338
    result = tailmatch(self, subobj, start, end, -1);
inline
             
tailmatch too costly to inline (cost=630, threshold=625) 
unicode_startswith
inline
             
tailmatch will not be inlined into unicode_startswith 
unicode_startswith
gvn
                                     
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_startswith
gvn
                                            
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_startswith
13339
    if (result == -1)
13340
        return NULL;
13341
    return PyBool_FromLong(result);
inline
           
PyBool_FromLong will not be inlined into unicode_startswith because its definition is unavailable 
unicode_startswith
13342
}
13343
13344
13345
PyDoc_STRVAR(endswith__doc__,
13346
             "S.endswith(suffix[, start[, end]]) -> bool\n\
13347
\n\
13348
Return True if S ends with the specified suffix, False otherwise.\n\
13349
With optional start, test S beginning at that position.\n\
13350
With optional end, stop comparing S at that position.\n\
13351
suffix can also be a tuple of strings to try.");
13352
13353
static PyObject *
13354
unicode_endswith(PyObject *self,
13355
                 PyObject *args)
13356
{
13357
    PyObject *subobj;
13358
    PyObject *substring;
13359
    Py_ssize_t start = 0;
13360
    Py_ssize_t end = PY_SSIZE_T_MAX;
13361
    int result;
13362
13363
    if (!stringlib_parse_args_finds("endswith", args, &subobj, &start, &end))
inline
         
stringlib_parse_args_finds too costly to inline (cost=330, threshold=325) 
unicode_endswith
inline
         
stringlib_parse_args_finds will not be inlined into unicode_endswith 
unicode_endswith
13364
        return NULL;
13365
    if (PyTuple_Check(subobj)) {
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_endswith
13366
        Py_ssize_t i;
13367
        for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) {
licm
                        
hosting load 
unicode_endswith
licm
                        
hosting getelementptr 
unicode_endswith
licm
                        
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_endswith
gvn
                        
load of type %struct._object* eliminated in favor of load 
unicode_endswith
gvn
                        
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_endswith
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_endswith
loop-vectorize
        
loop not vectorized 
unicode_endswith
13368
            substring = PyTuple_GET_ITEM(subobj, i);
licm
                        
hosting getelementptr 
unicode_endswith
licm
                        
hosting bitcast 
unicode_endswith
13369
            if (!PyUnicode_Check(substring)) {
13370
                PyErr_Format(PyExc_TypeError,
inline
                
PyErr_Format will not be inlined into unicode_endswith because its definition is unavailable 
unicode_endswith
gvn
                             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_endswith
gvn
                             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_endswith
13371
                             "tuple for endswith must only contain str, "
13372
                             "not %.100s",
13373
                             Py_TYPE(substring)->tp_name);
13374
                return NULL;
13375
            }
13376
            result = tailmatch(self, substring, start, end, +1);
inline
                     
tailmatch too costly to inline (cost=630, threshold=625) 
unicode_endswith
inline
                     
tailmatch will not be inlined into unicode_endswith 
unicode_endswith
licm
                                                
hosting load 
unicode_endswith
licm
                                                       
hosting load 
unicode_endswith
13377
            if (result == -1)
13378
                return NULL;
13379
            if (result) {
13380
                Py_RETURN_TRUE;
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_endswith
13381
            }
13382
        }
13383
        Py_RETURN_FALSE;
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_endswith
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_endswith
13384
    }
13385
    if (!PyUnicode_Check(subobj)) {
13386
        PyErr_Format(PyExc_TypeError,
inline
        
PyErr_Format will not be inlined into unicode_endswith because its definition is unavailable 
unicode_endswith
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_endswith
13387
                     "endswith first arg must be str or "
13388
                     "a tuple of str, not %.100s", Py_TYPE(subobj)->tp_name);
13389
        return NULL;
13390
    }
13391
    result = tailmatch(self, subobj, start, end, +1);
inline
             
tailmatch too costly to inline (cost=630, threshold=625) 
unicode_endswith
inline
             
tailmatch will not be inlined into unicode_endswith 
unicode_endswith
gvn
                                     
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_endswith
gvn
                                            
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_endswith
13392
    if (result == -1)
13393
        return NULL;
13394
    return PyBool_FromLong(result);
inline
           
PyBool_FromLong will not be inlined into unicode_endswith because its definition is unavailable 
unicode_endswith
13395
}
13396
13397
static inline void
13398
_PyUnicodeWriter_Update(_PyUnicodeWriter *writer)
13399
{
13400
    writer->maxchar = PyUnicode_MAX_CHAR_VALUE(writer->buffer);
gvn
                      
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
gvn
                      
load eliminated by PRE 
_PyUnicodeWriter_PrepareInternal
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
_PyUnicodeWriter_WriteStr
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
_PyUnicodeWriter_WriteASCIIString
13401
    writer->data = PyUnicode_DATA(writer->buffer);
gvn
                   
load of type i32 not eliminated in favor of load because it is clobbered by store 
_PyUnicodeWriter_Update
gvn
                   
load of type i32 not eliminated in favor of load because it is clobbered by store 
_PyUnicodeWriter_PrepareInternal
gvn
                   
load of type i32 not eliminated in favor of load because it is clobbered by store 
_PyUnicodeWriter_WriteStr
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicodeWriter_WriteStr
gvn
                   
load of type i32 not eliminated in favor of load because it is clobbered by store 
_PyUnicodeWriter_WriteASCIIString
gvn
                   
load of type i8* not eliminated because it is clobbered by store 
_PyUnicodeWriter_WriteASCIIString
13402
13403
    if (!writer->readonly) {
gvn
                 
load of type i8 not eliminated because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
gvn
                 
load of type i8 not eliminated because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
gvn
                 
load of type i8 not eliminated because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
gvn
                 
load of type i8 not eliminated because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
gvn
                 
load of type i8 eliminated in favor of 1 
_PyUnicodeWriter_WriteStr
gvn
                 
load of type i8 eliminated in favor of 1 
_PyUnicodeWriter_WriteASCIIString
13404
        writer->kind = PyUnicode_KIND(writer->buffer);
gvn
                       
load of type %struct.PyASCIIObject* eliminated in favor of inttoptr 
_PyUnicodeWriter_Update
gvn
                       
load of type i32 not eliminated because it is clobbered by store 
_PyUnicodeWriter_Update
gvn
                       
load of type i32 not eliminated because it is clobbered by store 
_PyUnicodeWriter_PrepareInternal
13405
        writer->size = PyUnicode_GET_LENGTH(writer->buffer);
13406
    }
13407
    else {
13408
        /* use a value smaller than PyUnicode_1BYTE_KIND() so
13409
           _PyUnicodeWriter_PrepareKind() will copy the buffer. */
13410
        writer->kind = PyUnicode_WCHAR_KIND;
13411
        assert(writer->kind <= PyUnicode_1BYTE_KIND);
13412
13413
        /* Copy-on-write mode: set buffer size to 0 so
13414
         * _PyUnicodeWriter_Prepare() will copy (and enlarge) the buffer on
13415
         * next write. */
13416
        writer->size = 0;
13417
    }
13418
}
13419
13420
void
13421
_PyUnicodeWriter_Init(_PyUnicodeWriter *writer)
13422
{
13423
    memset(writer, 0, sizeof(*writer));
13424
13425
    /* ASCII is the bare minimum */
13426
    writer->min_char = 127;
13427
13428
    /* use a value smaller than PyUnicode_1BYTE_KIND() so
13429
       _PyUnicodeWriter_PrepareKind() will copy the buffer. */
13430
    writer->kind = PyUnicode_WCHAR_KIND;
13431
    assert(writer->kind <= PyUnicode_1BYTE_KIND);
13432
}
13433
13434
int
13435
_PyUnicodeWriter_PrepareInternal(_PyUnicodeWriter *writer,
13436
                                 Py_ssize_t length, Py_UCS4 maxchar)
13437
{
13438
    Py_ssize_t newlen;
13439
    PyObject *newbuffer;
13440
13441
    assert(maxchar <= MAX_UNICODE);
13442
13443
    /* ensure that the _PyUnicodeWriter_Prepare macro was used */
13444
    assert((maxchar > writer->maxchar && length >= 0)
13445
           || length > 0);
13446
13447
    if (length > PY_SSIZE_T_MAX - writer->pos) {
13448
        PyErr_NoMemory();
inline
        
PyErr_NoMemory will not be inlined into _PyUnicodeWriter_PrepareInternal because its definition is unavailable 
_PyUnicodeWriter_PrepareInternal
13449
        return -1;
13450
    }
13451
    newlen = writer->pos + length;
13452
13453
    maxchar = Py_MAX(maxchar, writer->min_char);
13454
13455
    if (writer->buffer == NULL) {
13456
        assert(!writer->readonly);
13457
        if (writer->overallocate
13458
            && newlen <= (PY_SSIZE_T_MAX - newlen / OVERALLOCATE_FACTOR)) {
13459
            /* overallocate to limit the number of realloc() */
13460
            newlen += newlen / OVERALLOCATE_FACTOR;
13461
        }
13462
        if (newlen < writer->min_length)
13463
            newlen = writer->min_length;
13464
13465
        writer->buffer = PyUnicode_New(newlen, maxchar);
inline
                         
PyUnicode_New too costly to inline (cost=460, threshold=250) 
_PyUnicodeWriter_PrepareInternal
inline
                         
PyUnicode_New will not be inlined into _PyUnicodeWriter_PrepareInternal 
_PyUnicodeWriter_PrepareInternal
13466
        if (writer->buffer == NULL)
13467
            return -1;
13468
    }
13469
    else if (newlen > writer->size) {
13470
        if (writer->overallocate
13471
            && newlen <= (PY_SSIZE_T_MAX - newlen / OVERALLOCATE_FACTOR)) {
13472
            /* overallocate to limit the number of realloc() */
13473
            newlen += newlen / OVERALLOCATE_FACTOR;
13474
        }
13475
        if (newlen < writer->min_length)
13476
            newlen = writer->min_length;
13477
13478
        if (maxchar > writer->maxchar || writer->readonly) {
13479
            /* resize + widen */
13480
            maxchar = Py_MAX(maxchar, writer->maxchar);
13481
            newbuffer = PyUnicode_New(newlen, maxchar);
inline
                        
PyUnicode_New too costly to inline (cost=460, threshold=250) 
_PyUnicodeWriter_PrepareInternal
inline
                        
PyUnicode_New will not be inlined into _PyUnicodeWriter_PrepareInternal 
_PyUnicodeWriter_PrepareInternal
13482
            if (newbuffer == NULL)
13483
                return -1;
13484
            _PyUnicode_FastCopyCharacters(newbuffer, 0,
inline
            
_PyUnicode_FastCopyCharacters can be inlined into _PyUnicodeWriter_PrepareInternal with cost=5 (threshold=375) 
_PyUnicodeWriter_PrepareInternal
inline
            
_PyUnicode_FastCopyCharacters inlined into _PyUnicodeWriter_PrepareInternal 
_PyUnicodeWriter_PrepareInternal
13485
                                          writer->buffer, 0, writer->pos);
gvn
                                                  
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
gvn
                                                                     
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
13486
            Py_DECREF(writer->buffer);
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
13487
            writer->readonly = 0;
13488
        }
13489
        else {
13490
            newbuffer = resize_compact(writer->buffer, newlen);
inline
                        
resize_compact too costly to inline (cost=630, threshold=625) 
_PyUnicodeWriter_PrepareInternal
inline
                        
resize_compact will not be inlined into _PyUnicodeWriter_PrepareInternal 
_PyUnicodeWriter_PrepareInternal
gvn
                                               
load of type %struct._object* eliminated in favor of load 
_PyUnicodeWriter_PrepareInternal
13491
            if (newbuffer == NULL)
13492
                return -1;
13493
        }
13494
        writer->buffer = newbuffer;
13495
    }
13496
    else if (maxchar > writer->maxchar) {
13497
        assert(!writer->readonly);
13498
        newbuffer = PyUnicode_New(writer->size, maxchar);
inline
                    
PyUnicode_New too costly to inline (cost=460, threshold=250) 
_PyUnicodeWriter_PrepareInternal
inline
                    
PyUnicode_New will not be inlined into _PyUnicodeWriter_PrepareInternal 
_PyUnicodeWriter_PrepareInternal
13499
        if (newbuffer == NULL)
13500
            return -1;
13501
        _PyUnicode_FastCopyCharacters(newbuffer, 0,
inline
        
_PyUnicode_FastCopyCharacters can be inlined into _PyUnicodeWriter_PrepareInternal with cost=5 (threshold=375) 
_PyUnicodeWriter_PrepareInternal
inline
        
_PyUnicode_FastCopyCharacters inlined into _PyUnicodeWriter_PrepareInternal 
_PyUnicodeWriter_PrepareInternal
13502
                                      writer->buffer, 0, writer->pos);
gvn
                                              
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
gvn
                                                                 
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
13503
        Py_SETREF(writer->buffer, newbuffer);
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicodeWriter_PrepareInternal
13504
    }
13505
    _PyUnicodeWriter_Update(writer);
inline
    
_PyUnicodeWriter_Update can be inlined into _PyUnicodeWriter_PrepareInternal with cost=115 (threshold=325) 
_PyUnicodeWriter_PrepareInternal
inline
    
_PyUnicodeWriter_Update inlined into _PyUnicodeWriter_PrepareInternal 
_PyUnicodeWriter_PrepareInternal
13506
    return 0;
13507
13508
#undef OVERALLOCATE_FACTOR
13509
}
13510
13511
int
13512
_PyUnicodeWriter_PrepareKindInternal(_PyUnicodeWriter *writer,
13513
                                     enum PyUnicode_Kind kind)
13514
{
13515
    Py_UCS4 maxchar;
13516
13517
    /* ensure that the _PyUnicodeWriter_PrepareKind macro was used */
13518
    assert(writer->kind < kind);
13519
13520
    switch (kind)
13521
    {
13522
    case PyUnicode_1BYTE_KIND: maxchar = 0xff; break;
13523
    case PyUnicode_2BYTE_KIND: maxchar = 0xffff; break;
13524
    case PyUnicode_4BYTE_KIND: maxchar = 0x10ffff; break;
13525
    default:
13526
        assert(0 && "invalid kind");
13527
        return -1;
13528
    }
13529
13530
    return _PyUnicodeWriter_PrepareInternal(writer, 0, maxchar);
inline
           
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
_PyUnicodeWriter_PrepareKindInternal
inline
           
_PyUnicodeWriter_PrepareInternal will not be inlined into _PyUnicodeWriter_PrepareKindInternal 
_PyUnicodeWriter_PrepareKindInternal
inline
           
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF8Stateful
inline
           
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
inline
           
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeASCII
inline
           
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeASCII 
PyUnicode_DecodeASCII
13531
}
13532
13533
static inline int
13534
_PyUnicodeWriter_WriteCharInline(_PyUnicodeWriter *writer, Py_UCS4 ch)
13535
{
13536
    assert(ch <= MAX_UNICODE);
13537
    if (_PyUnicodeWriter_Prepare(writer, 1, ch) < 0)
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
_PyUnicodeWriter_WriteCharInline
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into _PyUnicodeWriter_WriteCharInline 
_PyUnicodeWriter_WriteCharInline
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF8Stateful
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeUTF8Stateful 
PyUnicode_DecodeUTF8Stateful
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
        
hosting getelementptr 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
        
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF8Stateful
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
unicode_fromformat_arg
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into unicode_fromformat_arg 
unicode_fromformat_arg
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
        
load of type i64 not eliminated because it is clobbered by store 
unicode_fromformat_arg
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_FromFormatV
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_FromFormatV 
PyUnicode_FromFormatV
licm
        
hosting getelementptr 
PyUnicode_FromFormatV
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF16Stateful
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeUTF16Stateful 
PyUnicode_DecodeUTF16Stateful
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
licm
        
hosting getelementptr 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
        
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF16Stateful
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF32Stateful
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeUTF32Stateful 
PyUnicode_DecodeUTF32Stateful
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
licm
        
hosting getelementptr 
PyUnicode_DecodeUTF32Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
        
load of type i64 eliminated in favor of phi 
PyUnicode_DecodeUTF32Stateful
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeUTF7Stateful
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeUTF7Stateful 
PyUnicode_DecodeUTF7Stateful
licm
        
hosting getelementptr 
PyUnicode_DecodeUTF7Stateful
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
_PyUnicode_DecodeUnicodeEscape
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into _PyUnicode_DecodeUnicodeEscape 
_PyUnicode_DecodeUnicodeEscape
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeRawUnicodeEscape
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeRawUnicodeEscape 
PyUnicode_DecodeRawUnicodeEscape
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
_PyUnicode_DecodeUnicodeInternal
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into _PyUnicode_DecodeUnicodeInternal 
_PyUnicode_DecodeUnicodeInternal
licm
        
hosting getelementptr 
_PyUnicode_DecodeUnicodeInternal
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeInternal
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
charmap_decode_string
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into charmap_decode_string 
charmap_decode_string
licm
        
hosting getelementptr 
charmap_decode_string
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
gvn
        
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
        
load of type i32 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
        
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
        
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
        
load of type i32 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
        
load of type i64 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
        
load of type i64 not eliminated because it is clobbered by store 
charmap_decode_string
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
charmap_decode_mapping
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into charmap_decode_mapping 
charmap_decode_mapping
licm
        
hosting getelementptr 
charmap_decode_mapping
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_mapping
gvn
        
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_DecodeCharmap
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_DecodeCharmap 
PyUnicode_DecodeCharmap
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
charmaptranslate_output
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into charmaptranslate_output 
charmaptranslate_output
gvn
        
load of type i32 not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
        
load of type i32 not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
        
load of type i64 not eliminated because it is clobbered by call 
charmaptranslate_output
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
_PyUnicode_TranslateCharmap
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into _PyUnicode_TranslateCharmap 
_PyUnicode_TranslateCharmap
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_TranslateCharmap
licm
        
hosting getelementptr 
_PyUnicode_TranslateCharmap
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type i32 not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
_PyUnicodeWriter_WriteChar
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into _PyUnicodeWriter_WriteChar 
_PyUnicodeWriter_WriteChar
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
unicode_format_arg_format
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into unicode_format_arg_format 
unicode_format_arg_format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
unicode_format_arg
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into unicode_format_arg 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_Format
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_Format 
PyUnicode_Format
licm
        
hosting getelementptr 
PyUnicode_Format
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
13538
        return -1;
13539
    PyUnicode_WRITE(writer->kind, writer->data, writer->pos, ch);
gvn
    
load of type i32 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteCharInline
gvn
    
load of type i16* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteCharInline
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteCharInline
gvn
    
load of type i8* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteCharInline
gvn
    
load of type i32* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteCharInline
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF8Stateful
licm
    
hosting bitcast 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type i32 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
    
load of type i16* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
    
load of type i8* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
    
load of type i32* not eliminated because it is clobbered by call 
unicode_fromformat_arg
gvn
    
load of type i32 not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
    
load of type i16* not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
    
load of type i8* not eliminated because it is clobbered by store 
unicode_fromformat_arg
gvn
    
load of type i32* not eliminated because it is clobbered by store 
unicode_fromformat_arg
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_FromFormatV
licm
    
hosting getelementptr 
PyUnicode_FromFormatV
licm
    
hosting bitcast 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF16Stateful
licm
    
hosting getelementptr 
PyUnicode_DecodeUTF16Stateful
licm
    
hosting bitcast 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type i8* not eliminated in favor of load because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type i8* not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF32Stateful
licm
    
hosting getelementptr 
PyUnicode_DecodeUTF32Stateful
licm
    
hosting bitcast 
PyUnicode_DecodeUTF32Stateful
gvn
    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
    
load eliminated by PRE 
PyUnicode_DecodeUTF32Stateful
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
    
load of type i8* not eliminated in favor of load because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeUTF7Stateful
licm
    
hosting getelementptr 
PyUnicode_DecodeUTF7Stateful
licm
    
hosting bitcast 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeEscape
licm
    
hosting getelementptr 
_PyUnicode_DecodeUnicodeEscape
licm
    
hosting bitcast 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load of type i32 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeRawUnicodeEscape
licm
    
hosting getelementptr 
PyUnicode_DecodeRawUnicodeEscape
licm
    
hosting bitcast 
PyUnicode_DecodeRawUnicodeEscape
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
    
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_DecodeUnicodeInternal
licm
    
hosting getelementptr 
_PyUnicode_DecodeUnicodeInternal
licm
    
hosting bitcast 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
licm
    
hosting getelementptr 
charmap_decode_string
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_string
licm
    
hosting bitcast 
charmap_decode_string
gvn
    
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
    
load of type i32 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
    
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
    
load of type i32 not eliminated because it is clobbered by store 
charmap_decode_string
gvn
    
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
    
load of type i16* not eliminated because it is clobbered by call 
charmap_decode_string
gvn
    
load of type i16* not eliminated because it is clobbered by store 
charmap_decode_string
gvn
    
load of type i16* not eliminated because it is clobbered by call 
charmap_decode_string
gvn
    
load of type i16* not eliminated because it is clobbered by store 
charmap_decode_string
gvn
    
load of type i16* not eliminated because it is clobbered by call 
charmap_decode_string
gvn
    
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_string
gvn
    
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_string
gvn
    
load of type i8* not eliminated because it is clobbered by store 
charmap_decode_string
gvn
    
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_string
gvn
    
load of type i8* not eliminated because it is clobbered by store 
charmap_decode_string
gvn
    
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_string
gvn
    
load of type i32* not eliminated because it is clobbered by call 
charmap_decode_string
gvn
    
load of type i32* not eliminated because it is clobbered by store 
charmap_decode_string
gvn
    
load of type i32* not eliminated because it is clobbered by call 
charmap_decode_string
gvn
    
load of type i32* not eliminated because it is clobbered by store 
charmap_decode_string
gvn
    
load of type i32* not eliminated because it is clobbered by call 
charmap_decode_string
licm
    
hosting getelementptr 
charmap_decode_mapping
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
charmap_decode_mapping
licm
    
hosting bitcast 
charmap_decode_mapping
gvn
    
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i16* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i16* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i64 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i32* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i32* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i32 not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i16* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i16* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i16* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i8* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i32* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i32* not eliminated because it is clobbered by call 
charmap_decode_mapping
gvn
    
load of type i32* not eliminated because it is clobbered by call 
charmap_decode_mapping
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_DecodeCharmap
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
    
load of type i32 not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
    
load of type i32 not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
    
load of type i16* not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
    
load of type i16* not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
    
load of type i64 not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
    
load of type i8* not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
    
load of type i8* not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
    
load of type i32* not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
    
load of type i32* not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
    
load of type i32 not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
    
load of type i16* not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
    
load of type i8* not eliminated because it is clobbered by call 
charmaptranslate_output
gvn
    
load of type i32* not eliminated because it is clobbered by call 
charmaptranslate_output
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
_PyUnicode_TranslateCharmap
licm
    
hosting getelementptr 
_PyUnicode_TranslateCharmap
licm
    
hosting bitcast 
_PyUnicode_TranslateCharmap
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i16* not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
    
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i16* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i8* not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
    
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i8* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i32* not eliminated because it is clobbered by store 
_PyUnicode_TranslateCharmap
gvn
    
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i32* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type i32 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteChar
gvn
    
load of type i16* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteChar
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteChar
gvn
    
load of type i8* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteChar
gvn
    
load of type i32* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteChar
gvn
    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
licm
    
hosting getelementptr 
PyUnicode_Format
licm
    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
    
hosting bitcast 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
13540
    writer->pos++;
gvn
               
load of type i64 not eliminated because it is clobbered by store 
_PyUnicodeWriter_WriteCharInline
gvn
               
load eliminated by PRE 
_PyUnicodeWriter_WriteCharInline
13541
    return 0;
13542
}
13543
13544
int
13545
_PyUnicodeWriter_WriteChar(_PyUnicodeWriter *writer, Py_UCS4 ch)
13546
{
13547
    return _PyUnicodeWriter_WriteCharInline(writer, ch);
inline
           
_PyUnicodeWriter_WriteCharInline can be inlined into _PyUnicodeWriter_WriteChar with cost=150 (threshold=325) 
_PyUnicodeWriter_WriteChar
inline
           
_PyUnicodeWriter_WriteCharInline inlined into _PyUnicodeWriter_WriteChar 
_PyUnicodeWriter_WriteChar
13548
}
13549
13550
int
13551
_PyUnicodeWriter_WriteStr(_PyUnicodeWriter *writer, PyObject *str)
13552
{
13553
    Py_UCS4 maxchar;
13554
    Py_ssize_t len;
13555
13556
    if (PyUnicode_READY(str) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicodeWriter_WriteStr
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicodeWriter_WriteStr 
_PyUnicodeWriter_WriteStr
13557
        return -1;
13558
    len = PyUnicode_GET_LENGTH(str);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteStr
13559
    if (len == 0)
13560
        return 0;
13561
    maxchar = PyUnicode_MAX_CHAR_VALUE(str);
gvn
              
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicodeWriter_WriteStr
13562
    if (maxchar > writer->maxchar || len > writer->size - writer->pos) {
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteStr
gvn
                                                   
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteStr
gvn
                                                                  
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteStr
13563
        if (writer->buffer == NULL && !writer->overallocate) {
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteStr
gvn
                                               
load of type i8 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteStr
13564
            assert(_PyUnicode_CheckConsistency(str, 1));
13565
            writer->readonly = 1;
13566
            Py_INCREF(str);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteStr
13567
            writer->buffer = str;
13568
            _PyUnicodeWriter_Update(writer);
inline
            
_PyUnicodeWriter_Update can be inlined into _PyUnicodeWriter_WriteStr with cost=115 (threshold=325) 
_PyUnicodeWriter_WriteStr
inline
            
_PyUnicodeWriter_Update inlined into _PyUnicodeWriter_WriteStr 
_PyUnicodeWriter_WriteStr
13569
            writer->pos += len;
gvn
                        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteStr
13570
            return 0;
13571
        }
13572
        if (_PyUnicodeWriter_PrepareInternal(writer, len, maxchar) == -1)
inline
            
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
_PyUnicodeWriter_WriteStr
inline
            
_PyUnicodeWriter_PrepareInternal will not be inlined into _PyUnicodeWriter_WriteStr 
_PyUnicodeWriter_WriteStr
13573
            return -1;
13574
    }
13575
    _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos,
inline
    
_PyUnicode_FastCopyCharacters can be inlined into _PyUnicodeWriter_WriteStr with cost=5 (threshold=375) 
_PyUnicodeWriter_WriteStr
inline
    
_PyUnicode_FastCopyCharacters inlined into _PyUnicodeWriter_WriteStr 
_PyUnicodeWriter_WriteStr
gvn
                                          
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteStr
gvn
                                          
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteStr
gvn
                                                          
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteStr
gvn
                                                          
load eliminated by PRE 
_PyUnicodeWriter_WriteStr
13576
                                  str, 0, len);
13577
    writer->pos += len;
gvn
                
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteStr
13578
    return 0;
13579
}
13580
13581
int
13582
_PyUnicodeWriter_WriteSubstring(_PyUnicodeWriter *writer, PyObject *str,
13583
                                Py_ssize_t start, Py_ssize_t end)
13584
{
13585
    Py_UCS4 maxchar;
13586
    Py_ssize_t len;
13587
13588
    if (PyUnicode_READY(str) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_PyUnicodeWriter_WriteSubstring
inline
        
_PyUnicode_Ready will not be inlined into _PyUnicodeWriter_WriteSubstring 
_PyUnicodeWriter_WriteSubstring
13589
        return -1;
13590
13591
    assert(0 <= start);
13592
    assert(end <= PyUnicode_GET_LENGTH(str));
13593
    assert(start <= end);
13594
13595
    if (end == 0)
13596
        return 0;
13597
13598
    if (start == 0 && end == PyUnicode_GET_LENGTH(str))
gvn
                             
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteSubstring
13599
        return _PyUnicodeWriter_WriteStr(writer, str);
inline
               
_PyUnicodeWriter_WriteStr too costly to inline (cost=445, threshold=250) 
_PyUnicodeWriter_WriteSubstring
inline
               
_PyUnicodeWriter_WriteStr will not be inlined into _PyUnicodeWriter_WriteSubstring 
_PyUnicodeWriter_WriteSubstring
13600
13601
    if (PyUnicode_MAX_CHAR_VALUE(str) > writer->maxchar)
gvn
        
load of type i32 not eliminated in favor of load because it is clobbered by call 
_PyUnicodeWriter_WriteSubstring
gvn
                                                
load of type i32 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteSubstring
13602
        maxchar = _PyUnicode_FindMaxChar(str, start, end);
inline
                  
_PyUnicode_FindMaxChar too costly to inline (cost=620, threshold=250) 
_PyUnicodeWriter_WriteSubstring
inline
                  
_PyUnicode_FindMaxChar will not be inlined into _PyUnicodeWriter_WriteSubstring 
_PyUnicodeWriter_WriteSubstring
13603
    else
13604
        maxchar = writer->maxchar;
13605
    len = end - start;
13606
13607
    if (_PyUnicodeWriter_Prepare(writer, len, maxchar) < 0)
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
_PyUnicodeWriter_WriteSubstring
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into _PyUnicodeWriter_WriteSubstring 
_PyUnicodeWriter_WriteSubstring
gvn
        
load of type i32 eliminated in favor of load 
_PyUnicodeWriter_WriteSubstring
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteSubstring
13608
        return -1;
13609
13610
    _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos,
inline
    
_PyUnicode_FastCopyCharacters can be inlined into _PyUnicodeWriter_WriteSubstring with cost=5 (threshold=375) 
_PyUnicodeWriter_WriteSubstring
inline
    
_PyUnicode_FastCopyCharacters inlined into _PyUnicodeWriter_WriteSubstring 
_PyUnicodeWriter_WriteSubstring
gvn
                                          
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteSubstring
gvn
                                          
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteSubstring
gvn
                                                          
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteSubstring
gvn
                                                          
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteSubstring
13611
                                  str, start, len);
13612
    writer->pos += len;
gvn
                
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicodeWriter_WriteSubstring
13613
    return 0;
13614
}
13615
13616
int
13617
_PyUnicodeWriter_WriteASCIIString(_PyUnicodeWriter *writer,
13618
                                  const char *ascii, Py_ssize_t len)
13619
{
13620
    if (len == -1)
13621
        len = strlen(ascii);
inline
              
strlen will not be inlined into _PyUnicodeWriter_WriteASCIIString because its definition is unavailable 
_PyUnicodeWriter_WriteASCIIString
13622
13623
    assert(ucs1lib_find_max_char((Py_UCS1*)ascii, (Py_UCS1*)ascii + len) < 128);
13624
13625
    if (writer->buffer == NULL && !writer->overallocate) {
13626
        PyObject *str;
13627
13628
        str = _PyUnicode_FromASCII(ascii, len);
inline
              
_PyUnicode_FromASCII can be inlined into _PyUnicodeWriter_WriteASCIIString with cost=215 (threshold=250) 
_PyUnicodeWriter_WriteASCIIString
inline
              
_PyUnicode_FromASCII inlined into _PyUnicodeWriter_WriteASCIIString 
_PyUnicodeWriter_WriteASCIIString
13629
        if (str == NULL)
13630
            return -1;
13631
13632
        writer->readonly = 1;
13633
        writer->buffer = str;
13634
        _PyUnicodeWriter_Update(writer);
inline
        
_PyUnicodeWriter_Update can be inlined into _PyUnicodeWriter_WriteASCIIString with cost=-14885 (threshold=325) 
_PyUnicodeWriter_WriteASCIIString
inline
        
_PyUnicodeWriter_Update inlined into _PyUnicodeWriter_WriteASCIIString 
_PyUnicodeWriter_WriteASCIIString
13635
        writer->pos += len;
gvn
                    
load of type i64 not eliminated because it is clobbered by store 
_PyUnicodeWriter_WriteASCIIString
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
13636
        return 0;
13637
    }
13638
13639
    if (_PyUnicodeWriter_Prepare(writer, len, 127) == -1)
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
_PyUnicodeWriter_WriteASCIIString
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into _PyUnicodeWriter_WriteASCIIString 
_PyUnicodeWriter_WriteASCIIString
13640
        return -1;
13641
13642
    switch (writer->kind)
gvn
                    
load of type i32 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
13643
    {
13644
    case PyUnicode_1BYTE_KIND:
13645
    {
13646
        const Py_UCS1 *str = (const Py_UCS1 *)ascii;
13647
        Py_UCS1 *data = writer->data;
gvn
                                
load of type i8* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
13648
13649
        memcpy(data + writer->pos, str, len);
gvn
                              
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
13650
        break;
13651
    }
13652
    case PyUnicode_2BYTE_KIND:
13653
    {
13654
        _PyUnicode_CONVERT_BYTES(
gvn
        
load of type i16* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
gvn
        
load of type i8 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
gvn
        
load of type i8 not eliminated because it is clobbered by store 
_PyUnicodeWriter_WriteASCIIString
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
_PyUnicodeWriter_WriteASCIIString
loop-vectorize
        
loop not vectorized 
_PyUnicodeWriter_WriteASCIIString
loop-vectorize
        
vectorized loop (vectorization width: 8, interleaved count: 2) 
_PyUnicodeWriter_WriteASCIIString
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
_PyUnicodeWriter_WriteASCIIString
13655
            Py_UCS1, Py_UCS2,
13656
            ascii, ascii + len,
13657
            (Py_UCS2 *)writer->data + writer->pos);
13658
        break;
13659
    }
13660
    case PyUnicode_4BYTE_KIND:
13661
    {
13662
        _PyUnicode_CONVERT_BYTES(
gvn
        
load of type i32* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
gvn
        
load of type i8 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
gvn
        
load of type i8 not eliminated because it is clobbered by store 
_PyUnicodeWriter_WriteASCIIString
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
_PyUnicodeWriter_WriteASCIIString
loop-vectorize
        
loop not vectorized 
_PyUnicodeWriter_WriteASCIIString
loop-vectorize
        
vectorized loop (vectorization width: 4, interleaved count: 2) 
_PyUnicodeWriter_WriteASCIIString
loop-unroll
        
unrolled loop by a factor of 2 with run-time trip count 
_PyUnicodeWriter_WriteASCIIString
13663
            Py_UCS1, Py_UCS4,
13664
            ascii, ascii + len,
13665
            (Py_UCS4 *)writer->data + writer->pos);
13666
        break;
13667
    }
13668
    default:
13669
        assert(0);
13670
    }
13671
13672
    writer->pos += len;
gvn
                
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
gvn
                
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteASCIIString
13673
    return 0;
13674
}
13675
13676
int
13677
_PyUnicodeWriter_WriteLatin1String(_PyUnicodeWriter *writer,
13678
                                   const char *str, Py_ssize_t len)
13679
{
13680
    Py_UCS4 maxchar;
13681
13682
    maxchar = ucs1lib_find_max_char((Py_UCS1*)str, (Py_UCS1*)str + len);
inline
              
ucs1lib_find_max_char can be inlined into _PyUnicodeWriter_WriteLatin1String with cost=60 (threshold=325) 
_PyUnicodeWriter_WriteLatin1String
inline
              
ucs1lib_find_max_char inlined into _PyUnicodeWriter_WriteLatin1String 
_PyUnicodeWriter_WriteLatin1String
13683
    if (_PyUnicodeWriter_Prepare(writer, len, maxchar) == -1)
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
_PyUnicodeWriter_WriteLatin1String
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into _PyUnicodeWriter_WriteLatin1String 
_PyUnicodeWriter_WriteLatin1String
13684
        return -1;
13685
    unicode_write_cstr(writer->buffer, writer->pos, str, len);
inline
    
unicode_write_cstr can be inlined into _PyUnicodeWriter_WriteLatin1String with cost=-14895 (threshold=250) 
_PyUnicodeWriter_WriteLatin1String
inline
    
unicode_write_cstr inlined into _PyUnicodeWriter_WriteLatin1String 
_PyUnicodeWriter_WriteLatin1String
gvn
                               
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteLatin1String
gvn
                                               
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_WriteLatin1String
13686
    writer->pos += len;
gvn
                
load of type i64 not eliminated in favor of load because it is clobbered by call 
_PyUnicodeWriter_WriteLatin1String
gvn
                
load eliminated by PRE 
_PyUnicodeWriter_WriteLatin1String
13687
    return 0;
13688
}
13689
13690
PyObject *
13691
_PyUnicodeWriter_Finish(_PyUnicodeWriter *writer)
13692
{
13693
    PyObject *str;
13694
13695
    if (writer->pos == 0) {
13696
        Py_CLEAR(writer->buffer);
13697
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
_PyUnicodeWriter_Finish
inline
        
PyUnicode_New will not be inlined into _PyUnicodeWriter_Finish 
_PyUnicodeWriter_Finish
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicodeWriter_Finish
gvn
        
load of type %struct._object* eliminated in favor of phi 
_PyUnicodeWriter_Finish
13698
    }
13699
13700
    str = writer->buffer;
13701
    writer->buffer = NULL;
13702
13703
    if (writer->readonly) {
13704
        assert(PyUnicode_GET_LENGTH(str) == writer->pos);
13705
        return str;
13706
    }
13707
13708
    if (PyUnicode_GET_LENGTH(str) != writer->pos) {
13709
        PyObject *str2;
13710
        str2 = resize_compact(str, writer->pos);
inline
               
resize_compact too costly to inline (cost=630, threshold=625) 
_PyUnicodeWriter_Finish
inline
               
resize_compact will not be inlined into _PyUnicodeWriter_Finish 
_PyUnicodeWriter_Finish
13711
        if (str2 == NULL) {
13712
            Py_DECREF(str);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicodeWriter_Finish
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicodeWriter_Finish
13713
            return NULL;
13714
        }
13715
        str = str2;
13716
    }
13717
13718
    assert(_PyUnicode_CheckConsistency(str, 1));
13719
    return unicode_result_ready(str);
inline
           
unicode_result_ready too costly to inline (cost=335, threshold=250) 
_PyUnicodeWriter_Finish
inline
           
unicode_result_ready will not be inlined into _PyUnicodeWriter_Finish 
_PyUnicodeWriter_Finish
13720
}
13721
13722
void
13723
_PyUnicodeWriter_Dealloc(_PyUnicodeWriter *writer)
13724
{
13725
    Py_CLEAR(writer->buffer);
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF8Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_FromFormatV
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF16Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF32Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeASCII
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeUTF7Stateful
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeEscape
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeRawUnicodeEscape
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_DecodeUnicodeInternal
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_DecodeCharmap
gvn
    
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_TranslateCharmap
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
build_string
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
build_string
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
build_string
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode__format__
13726
}
13727
13728
#include "stringlib/unicode_format.h"
13729
13730
PyDoc_STRVAR(format__doc__,
13731
             "S.format(*args, **kwargs) -> str\n\
13732
\n\
13733
Return a formatted version of S, using substitutions from args and kwargs.\n\
13734
The substitutions are identified by braces ('{' and '}').");
13735
13736
PyDoc_STRVAR(format_map__doc__,
13737
             "S.format_map(mapping) -> str\n\
13738
\n\
13739
Return a formatted version of S, using substitutions from mapping.\n\
13740
The substitutions are identified by braces ('{' and '}').");
13741
13742
static PyObject *
13743
unicode__format__(PyObject* self, PyObject* args)
13744
{
13745
    PyObject *format_spec;
13746
    _PyUnicodeWriter writer;
13747
    int ret;
13748
13749
    if (!PyArg_ParseTuple(args, "U:__format__", &format_spec))
inline
         
_PyArg_ParseTuple_SizeT will not be inlined into unicode__format__ because its definition is unavailable 
unicode__format__
13750
        return NULL;
13751
13752
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode__format__
inline
        
_PyUnicode_Ready will not be inlined into unicode__format__ 
unicode__format__
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode__format__
13753
        return NULL;
13754
    _PyUnicodeWriter_Init(&writer);
inline
    
_PyUnicodeWriter_Init can be inlined into unicode__format__ with cost=-30 (threshold=375) 
unicode__format__
inline
    
_PyUnicodeWriter_Init inlined into unicode__format__ 
unicode__format__
13755
    ret = _PyUnicode_FormatAdvancedWriter(&writer,
inline
          
_PyUnicode_FormatAdvancedWriter will not be inlined into unicode__format__ because its definition is unavailable 
unicode__format__
13756
                                          self, format_spec, 0,
gvn
                                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode__format__
gvn
                                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode__format__
13757
                                          PyUnicode_GET_LENGTH(format_spec));
gvn
                                          
load of type i64 not eliminated because it is clobbered by call 
unicode__format__
13758
    if (ret == -1) {
13759
        _PyUnicodeWriter_Dealloc(&writer);
inline
        
_PyUnicodeWriter_Dealloc can be inlined into unicode__format__ with cost=20 (threshold=250) 
unicode__format__
inline
        
_PyUnicodeWriter_Dealloc inlined into unicode__format__ 
unicode__format__
13760
        return NULL;
13761
    }
13762
    return _PyUnicodeWriter_Finish(&writer);
inline
           
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
unicode__format__
inline
           
_PyUnicodeWriter_Finish will not be inlined into unicode__format__ 
unicode__format__
13763
}
13764
13765
PyDoc_STRVAR(p_format__doc__,
13766
             "S.__format__(format_spec) -> str\n\
13767
\n\
13768
Return a formatted version of S as described by format_spec.");
13769
13770
static PyObject *
13771
unicode__sizeof__(PyObject *v)
13772
{
13773
    Py_ssize_t size;
13774
13775
    /* If it's a compact object, account for base structure +
13776
       character data. */
13777
    if (PyUnicode_IS_COMPACT_ASCII(v))
13778
        size = sizeof(PyASCIIObject) + PyUnicode_GET_LENGTH(v) + 1;
13779
    else if (PyUnicode_IS_COMPACT(v))
13780
        size = sizeof(PyCompactUnicodeObject) +
13781
            (PyUnicode_GET_LENGTH(v) + 1) * PyUnicode_KIND(v);
13782
    else {
13783
        /* If it is a two-block object, account for base object, and
13784
           for character block if present. */
13785
        size = sizeof(PyUnicodeObject);
13786
        if (_PyUnicode_DATA_ANY(v))
13787
            size += (PyUnicode_GET_LENGTH(v) + 1) *
13788
                PyUnicode_KIND(v);
13789
    }
13790
    /* If the wstr pointer is present, account for it unless it is shared
13791
       with the data pointer. Check if the data is not shared. */
13792
    if (_PyUnicode_HAS_WSTR_MEMORY(v))
gvn
        
load of type i32 eliminated in favor of load 
unicode__sizeof__
13793
        size += (PyUnicode_WSTR_LENGTH(v) + 1) * sizeof(wchar_t);
gvn
                 
load of type i32 eliminated in favor of load 
unicode__sizeof__
13794
    if (_PyUnicode_HAS_UTF8_MEMORY(v))
gvn
        
load of type i32 eliminated in favor of load 
unicode__sizeof__
13795
        size += PyUnicode_UTF8_LENGTH(v) + 1;
gvn
                
load of type i32 eliminated in favor of load 
unicode__sizeof__
13796
13797
    return PyLong_FromSsize_t(size);
inline
           
PyLong_FromSsize_t will not be inlined into unicode__sizeof__ because its definition is unavailable 
unicode__sizeof__
13798
}
13799
13800
PyDoc_STRVAR(sizeof__doc__,
13801
             "S.__sizeof__() -> size of S in memory, in bytes");
13802
13803
static PyObject *
13804
unicode_getnewargs(PyObject *v)
13805
{
13806
    PyObject *copy = _PyUnicode_Copy(v);
inline
                     
_PyUnicode_Copy too costly to inline (cost=295, threshold=250) 
unicode_getnewargs
inline
                     
_PyUnicode_Copy will not be inlined into unicode_getnewargs 
unicode_getnewargs
13807
    if (!copy)
13808
        return NULL;
13809
    return Py_BuildValue("(N)", copy);
inline
           
_Py_BuildValue_SizeT will not be inlined into unicode_getnewargs because its definition is unavailable 
unicode_getnewargs
13810
}
13811
13812
static PyMethodDef unicode_methods[] = {
13813
    {"encode", (PyCFunction) unicode_encode, METH_VARARGS | METH_KEYWORDS, encode__doc__},
13814
    {"replace", (PyCFunction) unicode_replace, METH_VARARGS, replace__doc__},
13815
    {"split", (PyCFunction) unicode_split, METH_VARARGS | METH_KEYWORDS, split__doc__},
13816
    {"rsplit", (PyCFunction) unicode_rsplit, METH_VARARGS | METH_KEYWORDS, rsplit__doc__},
13817
    {"join", (PyCFunction) unicode_join, METH_O, join__doc__},
13818
    {"capitalize", (PyCFunction) unicode_capitalize, METH_NOARGS, capitalize__doc__},
13819
    {"casefold", (PyCFunction) unicode_casefold, METH_NOARGS, casefold__doc__},
13820
    {"title", (PyCFunction) unicode_title, METH_NOARGS, title__doc__},
13821
    {"center", (PyCFunction) unicode_center, METH_VARARGS, center__doc__},
13822
    {"count", (PyCFunction) unicode_count, METH_VARARGS, count__doc__},
13823
    {"expandtabs", (PyCFunction) unicode_expandtabs,
13824
     METH_VARARGS | METH_KEYWORDS, expandtabs__doc__},
13825
    {"find", (PyCFunction) unicode_find, METH_VARARGS, find__doc__},
13826
    {"partition", (PyCFunction) unicode_partition, METH_O, partition__doc__},
13827
    {"index", (PyCFunction) unicode_index, METH_VARARGS, index__doc__},
13828
    {"ljust", (PyCFunction) unicode_ljust, METH_VARARGS, ljust__doc__},
13829
    {"lower", (PyCFunction) unicode_lower, METH_NOARGS, lower__doc__},
13830
    {"lstrip", (PyCFunction) unicode_lstrip, METH_VARARGS, lstrip__doc__},
13831
    {"rfind", (PyCFunction) unicode_rfind, METH_VARARGS, rfind__doc__},
13832
    {"rindex", (PyCFunction) unicode_rindex, METH_VARARGS, rindex__doc__},
13833
    {"rjust", (PyCFunction) unicode_rjust, METH_VARARGS, rjust__doc__},
13834
    {"rstrip", (PyCFunction) unicode_rstrip, METH_VARARGS, rstrip__doc__},
13835
    {"rpartition", (PyCFunction) unicode_rpartition, METH_O, rpartition__doc__},
13836
    {"splitlines", (PyCFunction) unicode_splitlines,
13837
     METH_VARARGS | METH_KEYWORDS, splitlines__doc__},
13838
    {"strip", (PyCFunction) unicode_strip, METH_VARARGS, strip__doc__},
13839
    {"swapcase", (PyCFunction) unicode_swapcase, METH_NOARGS, swapcase__doc__},
13840
    {"translate", (PyCFunction) unicode_translate, METH_O, translate__doc__},
13841
    {"upper", (PyCFunction) unicode_upper, METH_NOARGS, upper__doc__},
13842
    {"startswith", (PyCFunction) unicode_startswith, METH_VARARGS, startswith__doc__},
13843
    {"endswith", (PyCFunction) unicode_endswith, METH_VARARGS, endswith__doc__},
13844
    {"islower", (PyCFunction) unicode_islower, METH_NOARGS, islower__doc__},
13845
    {"isupper", (PyCFunction) unicode_isupper, METH_NOARGS, isupper__doc__},
13846
    {"istitle", (PyCFunction) unicode_istitle, METH_NOARGS, istitle__doc__},
13847
    {"isspace", (PyCFunction) unicode_isspace, METH_NOARGS, isspace__doc__},
13848
    {"isdecimal", (PyCFunction) unicode_isdecimal, METH_NOARGS, isdecimal__doc__},
13849
    {"isdigit", (PyCFunction) unicode_isdigit, METH_NOARGS, isdigit__doc__},
13850
    {"isnumeric", (PyCFunction) unicode_isnumeric, METH_NOARGS, isnumeric__doc__},
13851
    {"isalpha", (PyCFunction) unicode_isalpha, METH_NOARGS, isalpha__doc__},
13852
    {"isalnum", (PyCFunction) unicode_isalnum, METH_NOARGS, isalnum__doc__},
13853
    {"isidentifier", (PyCFunction) unicode_isidentifier, METH_NOARGS, isidentifier__doc__},
13854
    {"isprintable", (PyCFunction) unicode_isprintable, METH_NOARGS, isprintable__doc__},
13855
    {"zfill", (PyCFunction) unicode_zfill, METH_VARARGS, zfill__doc__},
13856
    {"format", (PyCFunction) do_string_format, METH_VARARGS | METH_KEYWORDS, format__doc__},
13857
    {"format_map", (PyCFunction) do_string_format_map, METH_O, format_map__doc__},
13858
    {"__format__", (PyCFunction) unicode__format__, METH_VARARGS, p_format__doc__},
13859
    UNICODE_MAKETRANS_METHODDEF
13860
    {"__sizeof__", (PyCFunction) unicode__sizeof__, METH_NOARGS, sizeof__doc__},
13861
#if 0
13862
    /* These methods are just used for debugging the implementation. */
13863
    {"_decimal2ascii", (PyCFunction) unicode__decimal2ascii, METH_NOARGS},
13864
#endif
13865
13866
    {"__getnewargs__",  (PyCFunction)unicode_getnewargs, METH_NOARGS},
13867
    {NULL, NULL}
13868
};
13869
13870
static PyObject *
13871
unicode_mod(PyObject *v, PyObject *w)
13872
{
13873
    if (!PyUnicode_Check(v))
13874
        Py_RETURN_NOTIMPLEMENTED;
13875
    return PyUnicode_Format(v, w);
inline
           
PyUnicode_Format too costly to inline (cost=630, threshold=625) 
unicode_mod
inline
           
PyUnicode_Format will not be inlined into unicode_mod 
unicode_mod
13876
}
13877
13878
static PyNumberMethods unicode_as_number = {
13879
    0,              /*nb_add*/
13880
    0,              /*nb_subtract*/
13881
    0,              /*nb_multiply*/
13882
    unicode_mod,            /*nb_remainder*/
13883
};
13884
13885
static PySequenceMethods unicode_as_sequence = {
13886
    (lenfunc) unicode_length,       /* sq_length */
13887
    PyUnicode_Concat,           /* sq_concat */
13888
    (ssizeargfunc) unicode_repeat,  /* sq_repeat */
13889
    (ssizeargfunc) unicode_getitem,     /* sq_item */
13890
    0,                  /* sq_slice */
13891
    0,                  /* sq_ass_item */
13892
    0,                  /* sq_ass_slice */
13893
    PyUnicode_Contains,         /* sq_contains */
13894
};
13895
13896
static PyObject*
13897
unicode_subscript(PyObject* self, PyObject* item)
13898
{
13899
    if (PyUnicode_READY(self) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_subscript
inline
        
_PyUnicode_Ready will not be inlined into unicode_subscript 
unicode_subscript
13900
        return NULL;
13901
13902
    if (PyIndex_Check(item)) {
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_subscript
13903
        Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
inline
                       
PyNumber_AsSsize_t will not be inlined into unicode_subscript because its definition is unavailable 
unicode_subscript
gvn
                                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_subscript
13904
        if (i == -1 && PyErr_Occurred())
inline
                       
PyErr_Occurred will not be inlined into unicode_subscript because its definition is unavailable 
unicode_subscript
13905
            return NULL;
13906
        if (i < 0)
13907
            i += PyUnicode_GET_LENGTH(self);
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
unicode_subscript
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
unicode_subscript
13908
        return unicode_getitem(self, i);
inline
               
unicode_getitem too costly to inline (cost=590, threshold=250) 
unicode_subscript
inline
               
unicode_getitem will not be inlined into unicode_subscript 
unicode_subscript
13909
    } else if (PySlice_Check(item)) {
13910
        Py_ssize_t start, stop, step, slicelength, cur, i;
13911
        PyObject *result;
13912
        void *src_data, *dest_data;
13913
        int src_kind, dest_kind;
13914
        Py_UCS4 ch, max_char, kind_limit;
13915
13916
        if (PySlice_GetIndicesEx(item, PyUnicode_GET_LENGTH(self),
inline
            
PySlice_GetIndicesEx will not be inlined into unicode_subscript because its definition is unavailable 
unicode_subscript
gvn
                                       
load of type i64 not eliminated because it is clobbered by call 
unicode_subscript
13917
                                 &start, &stop, &step, &slicelength) < 0) {
13918
            return NULL;
13919
        }
13920
13921
        if (slicelength <= 0) {
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_subscript
13922
            _Py_RETURN_UNICODE_EMPTY();
inline
            
PyUnicode_New too costly to inline (cost=290, threshold=250) 
unicode_subscript
inline
            
PyUnicode_New will not be inlined into unicode_subscript 
unicode_subscript
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_subscript
gvn
            
load of type %struct._object* eliminated in favor of phi 
unicode_subscript
13923
        } else if (start == 0 && step == 1 &&
gvn
                   
load of type i64 not eliminated because it is clobbered by call 
unicode_subscript
gvn
                                 
load of type i64 not eliminated because it is clobbered by call 
unicode_subscript
13924
                   slicelength == PyUnicode_GET_LENGTH(self)) {
gvn
                                  
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_subscript
13925
            return unicode_result_unchanged(self);
inline
                   
unicode_result_unchanged can be inlined into unicode_subscript with cost=90 (threshold=250) 
unicode_subscript
inline
                   
unicode_result_unchanged inlined into unicode_subscript 
unicode_subscript
13926
        } else if (step == 1) {
13927
            return PyUnicode_Substring(self,
inline
                   
PyUnicode_Substring too costly to inline (cost=630, threshold=625) 
unicode_subscript
inline
                   
PyUnicode_Substring will not be inlined into unicode_subscript 
unicode_subscript
13928
                                       start, start + slicelength);
13929
        }
13930
        /* General case */
13931
        src_kind = PyUnicode_KIND(self);
gvn
                   
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_subscript
13932
        src_data = PyUnicode_DATA(self);
gvn
                   
load of type i8* not eliminated because it is clobbered by call 
unicode_subscript
13933
        if (!PyUnicode_IS_ASCII(self)) {
13934
            kind_limit = kind_maxchar_limit(src_kind);
inline
                         
kind_maxchar_limit can be inlined into unicode_subscript with cost=-15000 (threshold=250) 
unicode_subscript
inline
                         
kind_maxchar_limit inlined into unicode_subscript 
unicode_subscript
13935
            max_char = 0;
13936
            for (cur = start, i = 0; i < slicelength; cur += step, i++) {
licm
                                                             
hosting load 
unicode_subscript
licm
                                         
hosting load 
unicode_subscript
gvn
                       
load of type i64 eliminated in favor of load 
unicode_subscript
gvn
                                         
load of type i64 eliminated in favor of load 
unicode_subscript
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
unicode_subscript
loop-vectorize
            
loop not vectorized 
unicode_subscript
13937
                ch = PyUnicode_READ(src_kind, src_data, cur);
licm
                     
hosting trunc 
unicode_subscript
licm
                     
hosting bitcast 
unicode_subscript
13938
                if (ch > max_char) {
13939
                    max_char = ch;
13940
                    if (max_char >= kind_limit)
13941
                        break;
13942
                }
13943
            }
13944
        }
13945
        else
13946
            max_char = 127;
13947
        result = PyUnicode_New(slicelength, max_char);
inline
                 
PyUnicode_New too costly to inline (cost=460, threshold=250) 
unicode_subscript
inline
                 
PyUnicode_New will not be inlined into unicode_subscript 
unicode_subscript
gvn
                               
load of type i64 eliminated in favor of load 
unicode_subscript
13948
        if (result == NULL)
13949
            return NULL;
13950
        dest_kind = PyUnicode_KIND(result);
gvn
                    
load of type i32 not eliminated because it is clobbered by call 
unicode_subscript
13951
        dest_data = PyUnicode_DATA(result);
gvn
                    
load of type i8* not eliminated because it is clobbered by call 
unicode_subscript
13952
13953
        for (cur = start, i = 0; i < slicelength; cur += step, i++) {
licm
                                                         
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_subscript
licm
                                     
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_subscript
gvn
                   
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_subscript
gvn
                                     
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_subscript
gvn
                                                         
load of type i64 not eliminated in favor of load because it is clobbered by store 
unicode_subscript
gvn
                                     
load of type i64 not eliminated because it is clobbered by store 
unicode_subscript
licm
                                                         
hosting load 
unicode_subscript
licm
                                     
hosting load 
unicode_subscript
loop-vectorize
        
loop not vectorized 
unicode_subscript
loop-vectorize
        
loop not vectorized: could not determine number of loop iterations 
unicode_subscript
13954
            Py_UCS4 ch = PyUnicode_READ(src_kind, src_data, cur);
licm
                         
hosting trunc 
unicode_subscript
licm
                         
hosting bitcast 
unicode_subscript
13955
            PyUnicode_WRITE(dest_kind, dest_data, i, ch);
licm
            
hosting trunc 
unicode_subscript
licm
            
hosting bitcast 
unicode_subscript
licm
            
hosting icmp 
unicode_subscript
loop-vectorize
            
loop not vectorized: loop contains a switch statement 
unicode_subscript
loop-vectorize
            
loop not vectorized: control flow cannot be substituted for a select 
unicode_subscript
13956
        }
13957
        assert(_PyUnicode_CheckConsistency(result, 1));
13958
        return result;
13959
    } else {
13960
        PyErr_SetString(PyExc_TypeError, "string indices must be integers");
inline
        
PyErr_SetString will not be inlined into unicode_subscript because its definition is unavailable 
unicode_subscript
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_subscript
13961
        return NULL;
13962
    }
13963
}
13964
13965
static PyMappingMethods unicode_as_mapping = {
13966
    (lenfunc)unicode_length,        /* mp_length */
13967
    (binaryfunc)unicode_subscript,  /* mp_subscript */
13968
    (objobjargproc)0,           /* mp_ass_subscript */
13969
};
13970
13971
13972
/* Helpers for PyUnicode_Format() */
13973
13974
struct unicode_formatter_t {
13975
    PyObject *args;
13976
    int args_owned;
13977
    Py_ssize_t arglen, argidx;
13978
    PyObject *dict;
13979
13980
    enum PyUnicode_Kind fmtkind;
13981
    Py_ssize_t fmtcnt, fmtpos;
13982
    void *fmtdata;
13983
    PyObject *fmtstr;
13984
13985
    _PyUnicodeWriter writer;
13986
};
13987
13988
struct unicode_format_arg_t {
13989
    Py_UCS4 ch;
13990
    int flags;
13991
    Py_ssize_t width;
13992
    int prec;
13993
    int sign;
13994
};
13995
13996
static PyObject *
13997
unicode_format_getnextarg(struct unicode_formatter_t *ctx)
13998
{
13999
    Py_ssize_t argidx = ctx->argidx;
gvn
                             
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                             
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                             
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                             
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                             
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                             
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                             
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14000
14001
    if (argidx < ctx->arglen) {
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14002
        ctx->argidx++;
14003
        if (ctx->arglen < 0)
14004
            return ctx->args;
14005
        else
14006
            return PyTuple_GetItem(ctx->args, argidx);
inline
                   
PyTuple_GetItem will not be inlined into unicode_format_getnextarg because its definition is unavailable 
unicode_format_getnextarg
14007
    }
14008
    PyErr_SetString(PyExc_TypeError,
inline
    
PyErr_SetString will not be inlined into unicode_format_getnextarg because its definition is unavailable 
unicode_format_getnextarg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg_parse
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14009
                    "not enough arguments for format string");
14010
    return NULL;
14011
}
14012
14013
/* Returns a new reference to a PyUnicode object, or NULL on failure. */
14014
14015
/* Format a float into the writer if the writer is not NULL, or into *p_output
14016
   otherwise.
14017
14018
   Return 0 on success, raise an exception and return -1 on error. */
14019
static int
14020
formatfloat(PyObject *v, struct unicode_format_arg_t *arg,
14021
            PyObject **p_output,
14022
            _PyUnicodeWriter *writer)
14023
{
14024
    char *p;
14025
    double x;
14026
    Py_ssize_t len;
14027
    int prec;
14028
    int dtoa_flags;
14029
14030
    x = PyFloat_AsDouble(v);
inline
        
PyFloat_AsDouble will not be inlined into formatfloat because its definition is unavailable 
formatfloat
14031
    if (x == -1.0 && PyErr_Occurred())
inline
                     
PyErr_Occurred will not be inlined into formatfloat because its definition is unavailable 
formatfloat
14032
        return -1;
14033
14034
    prec = arg->prec;
gvn
                
load of type i32 not eliminated because it is clobbered by call 
formatfloat
gvn
                
load of type i32 not eliminated because it is clobbered by call 
formatfloat
14035
    if (prec < 0)
14036
        prec = 6;
14037
14038
    if (arg->flags & F_ALT)
gvn
             
load of type i32 not eliminated because it is clobbered by call 
formatfloat
gvn
             
load of type i32 not eliminated because it is clobbered by call 
formatfloat
14039
        dtoa_flags = Py_DTSF_ALT;
14040
    else
14041
        dtoa_flags = 0;
14042
    p = PyOS_double_to_string(x, arg->ch, prec, dtoa_flags, NULL);
inline
        
PyOS_double_to_string will not be inlined into formatfloat because its definition is unavailable 
formatfloat
gvn
                                      
load of type i32 not eliminated because it is clobbered by call 
formatfloat
gvn
                                      
load of type i32 not eliminated because it is clobbered by call 
formatfloat
14043
    if (p == NULL)
14044
        return -1;
14045
    len = strlen(p);
inline
          
strlen will not be inlined into formatfloat because its definition is unavailable 
formatfloat
14046
    if (writer) {
14047
        if (_PyUnicodeWriter_WriteASCIIString(writer, p, len) < 0) {
inline
            
_PyUnicodeWriter_WriteASCIIString too costly to inline (cost=630, threshold=625) 
formatfloat
inline
            
_PyUnicodeWriter_WriteASCIIString will not be inlined into formatfloat 
formatfloat
14048
            PyMem_Free(p);
inline
            
PyMem_Free will not be inlined into formatfloat because its definition is unavailable 
formatfloat
14049
            return -1;
14050
        }
14051
    }
14052
    else
14053
        *p_output = _PyUnicode_FromASCII(p, len);
inline
                    
_PyUnicode_FromASCII can be inlined into formatfloat with cost=215 (threshold=250) 
formatfloat
inline
                    
_PyUnicode_FromASCII inlined into formatfloat 
formatfloat
14054
    PyMem_Free(p);
inline
    
PyMem_Free will not be inlined into formatfloat because its definition is unavailable 
formatfloat
14055
    return 0;
14056
}
14057
14058
/* formatlong() emulates the format codes d, u, o, x and X, and
14059
 * the F_ALT flag, for Python's long (unbounded) ints.  It's not used for
14060
 * Python's regular ints.
14061
 * Return value:  a new PyUnicodeObject*, or NULL if error.
14062
 *     The output string is of the form
14063
 *         "-"? ("0x" | "0X")? digit+
14064
 *     "0x"/"0X" are present only for x and X conversions, with F_ALT
14065
 *         set in flags.  The case of hex digits will be correct,
14066
 *     There will be at least prec digits, zero-filled on the left if
14067
 *         necessary to get that many.
14068
 * val          object to be converted
14069
 * flags        bitmask of format flags; only F_ALT is looked at
14070
 * prec         minimum number of digits; 0-fill on left if needed
14071
 * type         a character in [duoxX]; u acts the same as d
14072
 *
14073
 * CAUTION:  o, x and X conversions on regular ints can never
14074
 * produce a '-' sign, but can for Python's unbounded ints.
14075
 */
14076
PyObject *
14077
_PyUnicode_FormatLong(PyObject *val, int alt, int prec, int type)
14078
{
14079
    PyObject *result = NULL;
14080
    char *buf;
14081
    Py_ssize_t i;
14082
    int sign;           /* 1 if '-', else 0 */
14083
    int len;            /* number of characters */
14084
    Py_ssize_t llen;
14085
    int numdigits;      /* len == numnondigits + numdigits */
14086
    int numnondigits = 0;
14087
14088
    /* Avoid exceeding SSIZE_T_MAX */
14089
    if (prec > INT_MAX-3) {
14090
        PyErr_SetString(PyExc_OverflowError,
inline
        
PyErr_SetString will not be inlined into _PyUnicode_FormatLong because its definition is unavailable 
_PyUnicode_FormatLong
14091
                        "precision too large");
14092
        return NULL;
14093
    }
14094
14095
    assert(PyLong_Check(val));
14096
14097
    switch (type) {
14098
    default:
14099
        assert(!"'type' not in [diuoxX]");
14100
    case 'd':
14101
    case 'i':
14102
    case 'u':
14103
        /* int and int subclasses should print numerically when a numeric */
14104
        /* format code is used (see issue18780) */
14105
        result = PyNumber_ToBase(val, 10);
inline
                 
PyNumber_ToBase will not be inlined into _PyUnicode_FormatLong because its definition is unavailable 
_PyUnicode_FormatLong
14106
        break;
14107
    case 'o':
14108
        numnondigits = 2;
14109
        result = PyNumber_ToBase(val, 8);
inline
                 
PyNumber_ToBase will not be inlined into _PyUnicode_FormatLong because its definition is unavailable 
_PyUnicode_FormatLong
14110
        break;
14111
    case 'x':
14112
    case 'X':
14113
        numnondigits = 2;
14114
        result = PyNumber_ToBase(val, 16);
inline
                 
PyNumber_ToBase will not be inlined into _PyUnicode_FormatLong because its definition is unavailable 
_PyUnicode_FormatLong
14115
        break;
14116
    }
14117
    if (!result)
14118
        return NULL;
14119
14120
    assert(unicode_modifiable(result));
14121
    assert(PyUnicode_IS_READY(result));
14122
    assert(PyUnicode_IS_ASCII(result));
14123
14124
    /* To modify the string in-place, there can only be one reference. */
14125
    if (Py_REFCNT(result) != 1) {
14126
        Py_DECREF(result);
14127
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into _PyUnicode_FormatLong because its definition is unavailable 
_PyUnicode_FormatLong
14128
        return NULL;
14129
    }
14130
    buf = PyUnicode_DATA(result);
14131
    llen = PyUnicode_GET_LENGTH(result);
gvn
           
load of type %struct._object* eliminated in favor of phi 
_PyUnicode_FormatLong
14132
    if (llen > INT_MAX) {
14133
        Py_DECREF(result);
gvn
        
load of type i64 eliminated in favor of load 
_PyUnicode_FormatLong
14134
        PyErr_SetString(PyExc_ValueError,
inline
        
PyErr_SetString will not be inlined into _PyUnicode_FormatLong because its definition is unavailable 
_PyUnicode_FormatLong
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
14135
                        "string too large in _PyUnicode_FormatLong");
14136
        return NULL;
14137
    }
14138
    len = (int)llen;
14139
    sign = buf[0] == '-';
14140
    numnondigits += sign;
14141
    numdigits = len - numnondigits;
14142
    assert(numdigits > 0);
14143
14144
    /* Get rid of base marker unless F_ALT */
14145
    if (((alt) == 0 &&
14146
        (type == 'o' || type == 'x' || type == 'X'))) {
14147
        assert(buf[sign] == '0');
14148
        assert(buf[sign+1] == 'x' || buf[sign+1] == 'X' ||
14149
               buf[sign+1] == 'o');
14150
        numnondigits -= 2;
14151
        buf += 2;
14152
        len -= 2;
14153
        if (sign)
14154
            buf[0] = '-';
14155
        assert(len == numnondigits + numdigits);
14156
        assert(numdigits > 0);
14157
    }
14158
14159
    /* Fill with leading zeroes to meet minimum width. */
14160
    if (prec > numdigits) {
14161
        PyObject *r1 = PyBytes_FromStringAndSize(NULL,
inline
                       
PyBytes_FromStringAndSize will not be inlined into _PyUnicode_FormatLong because its definition is unavailable 
_PyUnicode_FormatLong
14162
                                numnondigits + prec);
14163
        char *b1;
14164
        if (!r1) {
14165
            Py_DECREF(result);
gvn
            
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_FormatLong
14166
            return NULL;
14167
        }
14168
        b1 = PyBytes_AS_STRING(r1);
14169
        for (i = 0; i < numnondigits; ++i)
loop-vectorize
        
vectorized loop (vectorization width: 16, interleaved count: 2) 
_PyUnicode_FormatLong
loop-unroll
        
unrolled loop by a factor of 8 with run-time trip count 
_PyUnicode_FormatLong
loop-unroll
        
unrolled loop by a factor of 4 with run-time trip count 
_PyUnicode_FormatLong
14170
            *b1++ = *buf++;
gvn
                    
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
                    
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_FormatLong
14171
        for (i = 0; i < prec - numdigits; i++)
14172
            *b1++ = '0';
14173
        for (i = 0; i < numdigits; i++)
loop-vectorize
        
vectorized loop (vectorization width: 16, interleaved count: 2) 
_PyUnicode_FormatLong
loop-unroll
        
unrolled loop by a factor of 8 with run-time trip count 
_PyUnicode_FormatLong
loop-unroll
        
unrolled loop by a factor of 4 with run-time trip count 
_PyUnicode_FormatLong
14174
            *b1++ = *buf++;
gvn
                    
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_FormatLong
gvn
                    
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
                    
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
                    
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_FormatLong
14175
        *b1 = '\0';
14176
        Py_DECREF(result);
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_FormatLong
gvn
        
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_FormatLong
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
_PyUnicode_FormatLong
14177
        result = r1;
14178
        buf = PyBytes_AS_STRING(result);
14179
        len = numnondigits + prec;
14180
    }
14181
14182
    /* Fix up case for hex conversions. */
14183
    if (type == 'X') {
14184
        /* Need to convert all lower case letters to upper case.
14185
           and need to convert 0x to 0X (and -0x to -0X). */
14186
        for (i = 0; i < len; i++)
loop-vectorize
        
the cost-model indicates that interleaving is not beneficial 
_PyUnicode_FormatLong
14187
            if (buf[i] >= 'a' && buf[i] <= 'x')
gvn
                
load of type i8 not eliminated because it is clobbered by store 
_PyUnicode_FormatLong
gvn
                
load of type i8 not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
loop-vectorize
                
vectorized loop (vectorization width: 16, interleaved count: 1) 
_PyUnicode_FormatLong
loop-unroll
                
unrolled loop by a factor of 2 with run-time trip count 
_PyUnicode_FormatLong
14188
                buf[i] -= 'a'-'A';
14189
    }
14190
    if (!PyUnicode_Check(result)
gvn
         
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_FormatLong
gvn
         
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
_PyUnicode_FormatLong
14191
        || buf != PyUnicode_DATA(result)) {
14192
        PyObject *unicode;
14193
        unicode = _PyUnicode_FromASCII(buf, len);
inline
                  
_PyUnicode_FromASCII can be inlined into _PyUnicode_FormatLong with cost=215 (threshold=250) 
_PyUnicode_FormatLong
inline
                  
_PyUnicode_FromASCII inlined into _PyUnicode_FormatLong 
_PyUnicode_FormatLong
14194
        Py_DECREF(result);
gvn
        
load of type %struct._object* eliminated in favor of load 
_PyUnicode_FormatLong
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
        
load of type i64 not eliminated because it is clobbered by store 
_PyUnicode_FormatLong
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_FormatLong
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_FormatLong
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by store 
_PyUnicode_FormatLong
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_PyUnicode_FormatLong
14195
        result = unicode;
14196
    }
14197
    else if (len != PyUnicode_GET_LENGTH(result)) {
gvn
                    
load of type %struct.PyASCIIObject* eliminated in favor of inttoptr 
_PyUnicode_FormatLong
14198
        if (PyUnicode_Resize(&result, len) < 0)
inline
            
PyUnicode_Resize can be inlined into _PyUnicode_FormatLong with cost=90 (threshold=250) 
_PyUnicode_FormatLong
inline
            
PyUnicode_Resize inlined into _PyUnicode_FormatLong 
_PyUnicode_FormatLong
14199
            Py_CLEAR(result);
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
            
load eliminated by PRE 
_PyUnicode_FormatLong
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
            
load of type i64 not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
14200
    }
14201
    return result;
gvn
           
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_FormatLong
gvn
           
load eliminated by PRE 
_PyUnicode_FormatLong
14202
}
14203
14204
/* Format an integer or a float as an integer.
14205
 * Return 1 if the number has been formatted into the writer,
14206
 *        0 if the number has been formatted into *p_output
14207
 *       -1 and raise an exception on error */
14208
static int
14209
mainformatlong(PyObject *v,
14210
               struct unicode_format_arg_t *arg,
14211
               PyObject **p_output,
14212
               _PyUnicodeWriter *writer)
14213
{
14214
    PyObject *iobj, *res;
14215
    char type = (char)arg->ch;
gvn
                           
load of type i32 eliminated in favor of load 
unicode_format_arg_format
14216
14217
    if (!PyNumber_Check(v))
inline
         
PyNumber_Check will not be inlined into mainformatlong because its definition is unavailable 
mainformatlong
14218
        goto wrongtype;
14219
14220
    /* make sure number is a type of integer for o, x, and X */
14221
    if (!PyLong_Check(v)) {
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
mainformatlong
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
14222
        if (type == 'o' || type == 'x' || type == 'X') {
14223
            iobj = PyNumber_Index(v);
inline
                   
PyNumber_Index will not be inlined into mainformatlong because its definition is unavailable 
mainformatlong
14224
            if (iobj == NULL) {
14225
                if (PyErr_ExceptionMatches(PyExc_TypeError))
inline
                    
PyErr_ExceptionMatches will not be inlined into mainformatlong because its definition is unavailable 
mainformatlong
gvn
                                           
load of type %struct._object* not eliminated because it is clobbered by call 
mainformatlong
gvn
                                           
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                           
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                           
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14226
                    goto wrongtype;
14227
                return -1;
14228
            }
14229
        }
14230
        else {
14231
            iobj = PyNumber_Long(v);
inline
                   
PyNumber_Long will not be inlined into mainformatlong because its definition is unavailable 
mainformatlong
14232
            if (iobj == NULL ) {
14233
                if (PyErr_ExceptionMatches(PyExc_TypeError))
inline
                    
PyErr_ExceptionMatches will not be inlined into mainformatlong because its definition is unavailable 
mainformatlong
gvn
                                           
load of type %struct._object* not eliminated because it is clobbered by call 
mainformatlong
gvn
                                           
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                           
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                           
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14234
                    goto wrongtype;
14235
                return -1;
14236
            }
14237
        }
14238
        assert(PyLong_Check(iobj));
14239
    }
14240
    else {
14241
        iobj = v;
14242
        Py_INCREF(iobj);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
mainformatlong
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
14243
    }
14244
14245
    if (PyLong_CheckExact(v)
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
mainformatlong
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
mainformatlong
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_format
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_format
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Format
14246
        && arg->width == -1 && arg->prec == -1
gvn
                
load of type i64 not eliminated because it is clobbered by call 
mainformatlong
gvn
                
load of type i64 not eliminated because it is clobbered by call 
mainformatlong
gvn
                
load of type i64 not eliminated because it is clobbered by call 
mainformatlong
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
mainformatlong
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
mainformatlong
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
mainformatlong
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                
load of type i64 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                
load of type i64 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                    
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                    
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
                                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
14247
        && !(arg->flags & (F_SIGN | F_BLANK))
gvn
                  
load of type i32 not eliminated because it is clobbered by call 
mainformatlong
gvn
                  
load of type i32 not eliminated because it is clobbered by call 
mainformatlong
gvn
                  
load of type i32 not eliminated because it is clobbered by call 
mainformatlong
gvn
                  
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                  
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                  
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                  
load of type i32 eliminated in favor of phi 
unicode_format_arg
14248
        && type != 'X')
14249
    {
14250
        /* Fast path */
14251
        int alternate = arg->flags & F_ALT;
14252
        int base;
14253
14254
        switch(type)
14255
        {
14256
            default:
14257
                assert(0 && "'type' not in [diuoxX]");
14258
            case 'd':
14259
            case 'i':
14260
            case 'u':
14261
                base = 10;
14262
                break;
14263
            case 'o':
14264
                base = 8;
14265
                break;
14266
            case 'x':
14267
            case 'X':
14268
                base = 16;
14269
                break;
14270
        }
14271
14272
        if (_PyLong_FormatWriter(writer, v, base, alternate) == -1) {
inline
            
_PyLong_FormatWriter will not be inlined into mainformatlong because its definition is unavailable 
mainformatlong
14273
            Py_DECREF(iobj);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
mainformatlong
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
mainformatlong
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
14274
            return -1;
14275
        }
14276
        Py_DECREF(iobj);
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
mainformatlong
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
14277
        return 1;
14278
    }
14279
14280
    res = _PyUnicode_FormatLong(iobj, arg->flags & F_ALT, arg->prec, type);
inline
          
_PyUnicode_FormatLong too costly to inline (cost=630, threshold=625) 
mainformatlong
inline
          
_PyUnicode_FormatLong will not be inlined into mainformatlong 
mainformatlong
gvn
                                           
load of type i32 not eliminated because it is clobbered by call 
mainformatlong
gvn
                                           
load of type i32 not eliminated because it is clobbered by call 
mainformatlong
gvn
                                           
load of type i32 not eliminated because it is clobbered by call 
mainformatlong
gvn
                                                               
load of type i32 not eliminated because it is clobbered by call 
mainformatlong
gvn
                                                               
load of type i32 not eliminated because it is clobbered by call 
mainformatlong
gvn
                                                               
load of type i32 not eliminated because it is clobbered by call 
mainformatlong
inline
          
_PyUnicode_FormatLong too costly to inline (cost=630, threshold=625) 
unicode_format_arg_format
inline
          
_PyUnicode_FormatLong will not be inlined into unicode_format_arg_format 
unicode_format_arg_format
gvn
                                           
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                           
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                           
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                                               
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                                               
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                                               
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
inline
          
_PyUnicode_FormatLong too costly to inline (cost=630, threshold=625) 
unicode_format_arg
inline
          
_PyUnicode_FormatLong will not be inlined into unicode_format_arg 
unicode_format_arg
gvn
                                           
load of type i32 eliminated in favor of phi 
unicode_format_arg
gvn
                                                               
load of type i32 eliminated in favor of load 
unicode_format_arg
inline
          
_PyUnicode_FormatLong too costly to inline (cost=630, threshold=625) 
PyUnicode_Format
inline
          
_PyUnicode_FormatLong will not be inlined into PyUnicode_Format 
PyUnicode_Format
14281
    Py_DECREF(iobj);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
mainformatlong
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
mainformatlong
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
14282
    if (res == NULL)
14283
        return -1;
14284
    *p_output = res;
14285
    return 0;
14286
14287
wrongtype:
14288
    switch(type)
14289
    {
14290
        case 'o':
14291
        case 'x':
14292
        case 'X':
14293
            PyErr_Format(PyExc_TypeError,
inline
            
PyErr_Format will not be inlined into mainformatlong because its definition is unavailable 
mainformatlong
14294
                    "%%%c format: an integer is required, "
14295
                    "not %.200s",
14296
                    type, Py_TYPE(v)->tp_name);
14297
            break;
14298
        default:
14299
            PyErr_Format(PyExc_TypeError,
inline
            
PyErr_Format will not be inlined into mainformatlong because its definition is unavailable 
mainformatlong
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
mainformatlong
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
mainformatlong
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
mainformatlong
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14300
                    "%%%c format: a number is required, "
14301
                    "not %.200s",
14302
                    type, Py_TYPE(v)->tp_name);
gvn
                          
load of type %struct._typeobject* not eliminated because it is clobbered by call 
mainformatlong
gvn
                          
load of type %struct._typeobject* not eliminated because it is clobbered by call 
mainformatlong
gvn
                          
load of type %struct._typeobject* not eliminated because it is clobbered by call 
mainformatlong
gvn
                          
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                          
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                          
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                          
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
14303
            break;
14304
    }
14305
    return -1;
14306
}
14307
14308
static Py_UCS4
14309
formatchar(PyObject *v)
14310
{
14311
    /* presume that the buffer is at least 3 characters long */
14312
    if (PyUnicode_Check(v)) {
14313
        if (PyUnicode_GET_LENGTH(v) == 1) {
14314
            return PyUnicode_READ_CHAR(v, 0);
14315
        }
14316
        goto onError;
14317
    }
14318
    else {
14319
        PyObject *iobj;
14320
        long x;
14321
        /* make sure number is a type of integer */
14322
        if (!PyLong_Check(v)) {
14323
            iobj = PyNumber_Index(v);
inline
                   
PyNumber_Index will not be inlined into formatchar because its definition is unavailable 
formatchar
14324
            if (iobj == NULL) {
14325
                goto onError;
14326
            }
14327
            v = iobj;
14328
            Py_DECREF(iobj);
gvn
            
load of type i64 not eliminated because it is clobbered by call 
formatchar
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
formatchar
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
14329
        }
14330
        /* Integer input truncated to a character */
14331
        x = PyLong_AsLong(v);
inline
            
PyLong_AsLong will not be inlined into formatchar because its definition is unavailable 
formatchar
14332
        if (x == -1 && PyErr_Occurred())
inline
                       
PyErr_Occurred will not be inlined into formatchar because its definition is unavailable 
formatchar
14333
            goto onError;
14334
14335
        if (x < 0 || x > MAX_UNICODE) {
14336
            PyErr_SetString(PyExc_OverflowError,
inline
            
PyErr_SetString will not be inlined into formatchar because its definition is unavailable 
formatchar
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
formatchar
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
formatchar
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14337
                            "%c arg not in range(0x110000)");
14338
            return (Py_UCS4) -1;
14339
        }
14340
14341
        return (Py_UCS4) x;
14342
    }
14343
14344
  onError:
14345
    PyErr_SetString(PyExc_TypeError,
inline
    
PyErr_SetString will not be inlined into formatchar because its definition is unavailable 
formatchar
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
formatchar
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
formatchar
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14346
                    "%c requires int or char");
14347
    return (Py_UCS4) -1;
14348
}
14349
14350
/* Parse options of an argument: flags, width, precision.
14351
   Handle also "%(name)" syntax.
14352
14353
   Return 0 if the argument has been formatted into arg->str.
14354
   Return 1 if the argument has been written into ctx->writer,
14355
   Raise an exception and return -1 on error. */
14356
static int
14357
unicode_format_arg_parse(struct unicode_formatter_t *ctx,
14358
                         struct unicode_format_arg_t *arg)
14359
{
14360
#define FORMAT_READ(ctx) \
14361
        PyUnicode_READ((ctx)->fmtkind, (ctx)->fmtdata, (ctx)->fmtpos)
14362
14363
    PyObject *v;
14364
14365
    if (arg->ch == '(') {
gvn
             
load of type i32 eliminated in favor of phi 
unicode_format_arg
14366
        /* Get argument value from a dictionary. Example: "%(name)s". */
14367
        Py_ssize_t keystart;
14368
        Py_ssize_t keylen;
14369
        PyObject *key;
14370
        int pcount = 1;
14371
14372
        if (ctx->dict == NULL) {
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14373
            PyErr_SetString(PyExc_TypeError,
inline
            
PyErr_SetString will not be inlined into unicode_format_arg_parse because its definition is unavailable 
unicode_format_arg_parse
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14374
                            "format requires a mapping");
14375
            return -1;
14376
        }
14377
        ++ctx->fmtpos;
gvn
        
load of type i64 eliminated in favor of load 
unicode_format_arg
14378
        --ctx->fmtcnt;
14379
        keystart = ctx->fmtpos;
14380
        /* Skip over balanced parentheses */
14381
        while (pcount > 0 && --ctx->fmtcnt >= 0) {
licm
                      
hosting icmp 
unicode_format_arg_parse
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_Format
loop-vectorize
        
loop not vectorized 
PyUnicode_Format
14382
            arg->ch = FORMAT_READ(ctx);
licm
                      
hosting getelementptr 
unicode_format_arg_parse
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
                      
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg_parse
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg
gvn
                      
load of type i32 eliminated in favor of phi 
unicode_format_arg
gvn
                      
load of type i8* eliminated in favor of phi 
unicode_format_arg
gvn
                      
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
licm
                      
hosting icmp 
unicode_format_arg
licm
                      
hosting bitcast 
unicode_format_arg
14383
            if (arg->ch == ')')
14384
                --pcount;
14385
            else if (arg->ch == '(')
14386
                ++pcount;
14387
            ctx->fmtpos++;
14388
        }
14389
        keylen = ctx->fmtpos - keystart - 1;
gvn
                      
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg_parse
gvn
                      
load of type i64 eliminated in favor of add 
unicode_format_arg
14390
        if (ctx->fmtcnt < 0 || pcount > 0) {
14391
            PyErr_SetString(PyExc_ValueError,
inline
            
PyErr_SetString will not be inlined into unicode_format_arg_parse because its definition is unavailable 
unicode_format_arg_parse
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14392
                            "incomplete format key");
14393
            return -1;
14394
        }
14395
        key = PyUnicode_Substring(ctx->fmtstr,
inline
              
PyUnicode_Substring too costly to inline (cost=630, threshold=625) 
unicode_format_arg_parse
inline
              
PyUnicode_Substring will not be inlined into unicode_format_arg_parse 
unicode_format_arg_parse
inline
              
PyUnicode_Substring too costly to inline (cost=630, threshold=625) 
unicode_format_arg
inline
              
PyUnicode_Substring will not be inlined into unicode_format_arg 
unicode_format_arg
inline
              
PyUnicode_Substring too costly to inline (cost=630, threshold=625) 
PyUnicode_Format
inline
              
PyUnicode_Substring will not be inlined into PyUnicode_Format 
PyUnicode_Format
licm
                                       
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                       
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14396
                                  keystart, keystart + keylen);
14397
        if (key == NULL)
14398
            return -1;
14399
        if (ctx->args_owned) {
gvn
                 
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                 
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14400
            ctx->args_owned = 0;
14401
            Py_DECREF(ctx->args);
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
            
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14402
        }
14403
        ctx->args = PyObject_GetItem(ctx->dict, key);
inline
                    
PyObject_GetItem will not be inlined into unicode_format_arg_parse because its definition is unavailable 
unicode_format_arg_parse
gvn
                                          
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_parse
gvn
                                          
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_parse
gvn
                                          
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                                          
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
licm
                                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                                          
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                          
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                          
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
14404
        Py_DECREF(key);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
14405
        if (ctx->args == NULL)
gvn
                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_format_arg_parse
gvn
                 
load eliminated by PRE 
unicode_format_arg_parse
14406
            return -1;
14407
        ctx->args_owned = 1;
14408
        ctx->arglen = -1;
licm
                    
hosting bitcast 
PyUnicode_Format
14409
        ctx->argidx = -2;
14410
    }
14411
14412
    /* Parse flags. Example: "%+i" => flags=F_SIGN. */
14413
    while (--ctx->fmtcnt >= 0) {
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
           
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
gvn
           
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load eliminated by PRE 
PyUnicode_Format
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_Format
loop-vectorize
    
loop not vectorized 
PyUnicode_Format
14414
        arg->ch = FORMAT_READ(ctx);
licm
                  
hosting getelementptr 
unicode_format_arg_parse
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
                  
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                  
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                  
load eliminated by PRE 
unicode_format_arg_parse
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                  
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
licm
                  
hosting icmp 
unicode_format_arg_parse
licm
                
Moving accesses to memory location out of the loop 
unicode_format_arg
licm
                  
sinking zext 
PyUnicode_Format
14415
        ctx->fmtpos++;
licm
             
hosting getelementptr 
unicode_format_arg_parse
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
                   
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
licm
                   
Moving accesses to memory location out of the loop 
unicode_format_arg
14416
        switch (arg->ch) {
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
                     
load of type i32 eliminated in favor of phi 
unicode_format_arg_parse
14417
        case '-': arg->flags |= F_LJUST; continue;
licm
                       
hosting getelementptr 
unicode_format_arg_parse
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
14418
        case '+': arg->flags |= F_SIGN; continue;
licm
                       
hosting getelementptr 
unicode_format_arg_parse
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
14419
        case ' ': arg->flags |= F_BLANK; continue;
licm
                       
hosting getelementptr 
unicode_format_arg_parse
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
14420
        case '#': arg->flags |= F_ALT; continue;
licm
                       
hosting getelementptr 
unicode_format_arg_parse
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
14421
        case '0': arg->flags |= F_ZERO; continue;
licm
                       
hosting getelementptr 
unicode_format_arg_parse
licm
                             
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
14422
        }
14423
        break;
14424
    }
14425
14426
    /* Parse width. Example: "%10s" => width=10 */
14427
    if (arg->ch == '*') {
gvn
             
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_parse
gvn
             
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_parse
gvn
             
load eliminated by PRE 
unicode_format_arg_parse
14428
        v = unicode_format_getnextarg(ctx);
inline
            
unicode_format_getnextarg can be inlined into unicode_format_arg_parse with cost=95 (threshold=250) 
unicode_format_arg_parse
inline
            
unicode_format_getnextarg inlined into unicode_format_arg_parse 
unicode_format_arg_parse
14429
        if (v == NULL)
14430
            return -1;
14431
        if (!PyLong_Check(v)) {
14432
            PyErr_SetString(PyExc_TypeError,
inline
            
PyErr_SetString will not be inlined into unicode_format_arg_parse because its definition is unavailable 
unicode_format_arg_parse
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg_parse
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                            
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14433
                            "* wants int");
14434
            return -1;
14435
        }
14436
        arg->width = PyLong_AsSsize_t(v);
inline
                     
PyLong_AsSsize_t will not be inlined into unicode_format_arg_parse because its definition is unavailable 
unicode_format_arg_parse
14437
        if (arg->width == -1 && PyErr_Occurred())
inline
                                
PyErr_Occurred will not be inlined into unicode_format_arg_parse because its definition is unavailable 
unicode_format_arg_parse
14438
            return -1;
14439
        if (arg->width < 0) {
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg_parse
gvn
                 
load of type i64 eliminated in favor of call 
unicode_format_arg
14440
            arg->flags |= F_LJUST;
gvn
                       
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                       
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                       
load of type i32 eliminated in favor of phi 
unicode_format_arg
14441
            arg->width = -arg->width;
14442
        }
14443
        if (--ctx->fmtcnt >= 0) {
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14444
            arg->ch = FORMAT_READ(ctx);
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i8* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i8* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14445
            ctx->fmtpos++;
gvn
                       
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
14446
        }
14447
    }
14448
    else if (arg->ch >= '0' && arg->ch <= '9') {
14449
        arg->width = arg->ch - '0';
14450
        while (--ctx->fmtcnt >= 0) {
licm
               
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
               
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
loop-vectorize
        
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_Format
loop-vectorize
        
loop not vectorized 
PyUnicode_Format
14451
            arg->ch = FORMAT_READ(ctx);
licm
                      
hosting getelementptr 
unicode_format_arg_parse
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load eliminated by PRE 
unicode_format_arg_parse
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
licm
                      
hosting icmp 
unicode_format_arg_parse
licm
                      
hosting bitcast 
unicode_format_arg_parse
licm
                    
Moving accesses to memory location out of the loop 
unicode_format_arg
14452
            ctx->fmtpos++;
licm
                 
hosting getelementptr 
unicode_format_arg_parse
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
                       
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
licm
                       
Moving accesses to memory location out of the loop 
unicode_format_arg
14453
            if (arg->ch < '0' || arg->ch > '9')
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
                     
load of type i32 eliminated in favor of phi 
unicode_format_arg_parse
14454
                break;
14455
            /* Since arg->ch is unsigned, the RHS would end up as unsigned,
14456
               mixing signed and unsigned comparison. Since arg->ch is between
14457
               '0' and '9', casting to int is safe. */
14458
            if (arg->width > (PY_SSIZE_T_MAX - ((int)arg->ch - '0')) / 10) {
licm
                     
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
                     
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
14459
                PyErr_SetString(PyExc_ValueError,
inline
                
PyErr_SetString will not be inlined into unicode_format_arg_parse because its definition is unavailable 
unicode_format_arg_parse
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg_parse
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14460
                                "width too big");
14461
                return -1;
14462
            }
14463
            arg->width = arg->width*10 + (arg->ch - '0');
14464
        }
14465
    }
14466
14467
    /* Parse precision. Example: "%.3f" => prec=3 */
14468
    if (arg->ch == '.') {
gvn
             
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_parse
gvn
             
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_parse
gvn
             
load eliminated by PRE 
unicode_format_arg_parse
14469
        arg->prec = 0;
14470
        if (--ctx->fmtcnt >= 0) {
gvn
            
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
14471
            arg->ch = FORMAT_READ(ctx);
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                      
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i8* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i8* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i8* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i8* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i64 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14472
            ctx->fmtpos++;
gvn
                       
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
14473
        }
14474
        if (arg->ch == '*') {
gvn
                 
load of type i32 eliminated in favor of phi 
unicode_format_arg_parse
14475
            v = unicode_format_getnextarg(ctx);
inline
                
unicode_format_getnextarg can be inlined into unicode_format_arg_parse with cost=95 (threshold=250) 
unicode_format_arg_parse
inline
                
unicode_format_getnextarg inlined into unicode_format_arg_parse 
unicode_format_arg_parse
14476
            if (v == NULL)
14477
                return -1;
14478
            if (!PyLong_Check(v)) {
14479
                PyErr_SetString(PyExc_TypeError,
inline
                
PyErr_SetString will not be inlined into unicode_format_arg_parse because its definition is unavailable 
unicode_format_arg_parse
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg_parse
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14480
                                "* wants int");
14481
                return -1;
14482
            }
14483
            arg->prec = _PyLong_AsInt(v);
inline
                        
_PyLong_AsInt will not be inlined into unicode_format_arg_parse because its definition is unavailable 
unicode_format_arg_parse
14484
            if (arg->prec == -1 && PyErr_Occurred())
inline
                                   
PyErr_Occurred will not be inlined into unicode_format_arg_parse because its definition is unavailable 
unicode_format_arg_parse
14485
                return -1;
14486
            if (arg->prec < 0)
gvn
                     
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                     
load of type i32 eliminated in favor of call 
unicode_format_arg
14487
                arg->prec = 0;
14488
            if (--ctx->fmtcnt >= 0) {
gvn
                
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_parse
gvn
                
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_parse
gvn
                
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
licm
                
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
14489
                arg->ch = FORMAT_READ(ctx);
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i8* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i8* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14490
                ctx->fmtpos++;
gvn
                           
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
14491
            }
14492
        }
14493
        else if (arg->ch >= '0' && arg->ch <= '9') {
14494
            arg->prec = arg->ch - '0';
14495
            while (--ctx->fmtcnt >= 0) {
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
                   
load of type i64 eliminated in favor of add 
unicode_format_arg_parse
gvn
                   
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_Format
loop-vectorize
            
loop not vectorized 
PyUnicode_Format
14496
                arg->ch = FORMAT_READ(ctx);
licm
                          
hosting getelementptr 
unicode_format_arg_parse
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load eliminated by PRE 
unicode_format_arg_parse
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
licm
                          
hosting icmp 
unicode_format_arg_parse
licm
                          
hosting bitcast 
unicode_format_arg_parse
licm
                        
Moving accesses to memory location out of the loop 
unicode_format_arg
14497
                ctx->fmtpos++;
licm
                     
hosting getelementptr 
unicode_format_arg_parse
licm
                           
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
                           
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
licm
                           
Moving accesses to memory location out of the loop 
unicode_format_arg
14498
                if (arg->ch < '0' || arg->ch > '9')
licm
                         
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
                         
load of type i32 eliminated in favor of phi 
unicode_format_arg_parse
14499
                    break;
14500
                if (arg->prec > (INT_MAX - ((int)arg->ch - '0')) / 10) {
licm
                         
failed to move load with loop-invariant address because the loop may invalidate its value 
unicode_format_arg_parse
gvn
                         
load of type i32 eliminated in favor of phi 
unicode_format_arg_parse
14501
                    PyErr_SetString(PyExc_ValueError,
inline
                    
PyErr_SetString will not be inlined into unicode_format_arg_parse because its definition is unavailable 
unicode_format_arg_parse
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg_parse
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                    
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14502
                                    "precision too big");
14503
                    return -1;
14504
                }
14505
                arg->prec = arg->prec*10 + (arg->ch - '0');
14506
            }
14507
        }
14508
    }
14509
14510
    /* Ignore "h", "l" and "L" format prefix (ex: "%hi" or "%ls") */
14511
    if (ctx->fmtcnt >= 0) {
gvn
             
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
14512
        if (arg->ch == 'h' || arg->ch == 'l' || arg->ch == 'L') {
gvn
                 
load of type i32 eliminated in favor of phi 
unicode_format_arg_parse
14513
            if (--ctx->fmtcnt >= 0) {
14514
                arg->ch = FORMAT_READ(ctx);
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                          
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i8* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i8* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i8* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i8* not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i64 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
14515
                ctx->fmtpos++;
gvn
                           
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
14516
            }
14517
        }
14518
    }
14519
    if (ctx->fmtcnt < 0) {
gvn
             
load of type i64 eliminated in favor of phi 
unicode_format_arg_parse
14520
        PyErr_SetString(PyExc_ValueError,
inline
        
PyErr_SetString will not be inlined into unicode_format_arg_parse because its definition is unavailable 
unicode_format_arg_parse
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg_parse
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_parse
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14521
                        "incomplete format");
14522
        return -1;
14523
    }
14524
    return 0;
14525
14526
#undef FORMAT_READ
14527
}
14528
14529
/* Format one argument. Supported conversion specifiers:
14530
14531
   - "s", "r", "a": any type
14532
   - "i", "d", "u": int or float
14533
   - "o", "x", "X": int
14534
   - "e", "E", "f", "F", "g", "G": float
14535
   - "c": int or str (1 character)
14536
14537
   When possible, the output is written directly into the Unicode writer
14538
   (ctx->writer). A string is created when padding is required.
14539
14540
   Return 0 if the argument has been formatted into *p_str,
14541
          1 if the argument has been written into ctx->writer,
14542
         -1 on error. */
14543
static int
14544
unicode_format_arg_format(struct unicode_formatter_t *ctx,
14545
                          struct unicode_format_arg_t *arg,
14546
                          PyObject **p_str)
14547
{
14548
    PyObject *v;
14549
    _PyUnicodeWriter *writer = &ctx->writer;
14550
14551
    if (ctx->fmtcnt == 0)
gvn
             
load of type i64 eliminated in favor of phi 
unicode_format_arg
14552
        ctx->writer.overallocate = 0;
14553
14554
    if (arg->ch == '%') {
gvn
             
load of type i32 eliminated in favor of phi 
unicode_format_arg
14555
        if (_PyUnicodeWriter_WriteCharInline(writer, '%') < 0)
inline
            
_PyUnicodeWriter_WriteCharInline can be inlined into unicode_format_arg_format with cost=150 (threshold=325) 
unicode_format_arg_format
inline
            
_PyUnicodeWriter_WriteCharInline inlined into unicode_format_arg_format 
unicode_format_arg_format
14556
            return -1;
14557
        return 1;
14558
    }
14559
14560
    v = unicode_format_getnextarg(ctx);
inline
        
unicode_format_getnextarg can be inlined into unicode_format_arg_format with cost=-14905 (threshold=250) 
unicode_format_arg_format
inline
        
unicode_format_getnextarg inlined into unicode_format_arg_format 
unicode_format_arg_format
14561
    if (v == NULL)
14562
        return -1;
14563
14564
14565
    switch (arg->ch) {
gvn
                 
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_format
gvn
                 
load of type i32 eliminated in favor of phi 
unicode_format_arg
14566
    case 's':
14567
    case 'r':
14568
    case 'a':
14569
        if (PyLong_CheckExact(v) && arg->width == -1 && arg->prec == -1) {
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                                             
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                                             
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
licm
                                         
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
                                                             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                             
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                                             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14570
            /* Fast path */
14571
            if (_PyLong_FormatWriter(writer, v, 10, arg->flags & F_ALT) == -1)
inline
                
_PyLong_FormatWriter will not be inlined into unicode_format_arg_format because its definition is unavailable 
unicode_format_arg_format
gvn
                                                         
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                                         
load of type i32 eliminated in favor of phi 
unicode_format_arg
14572
                return -1;
14573
            return 1;
14574
        }
14575
14576
        if (PyUnicode_CheckExact(v) && arg->ch == 's') {
14577
            *p_str = v;
14578
            Py_INCREF(*p_str);
14579
        }
14580
        else {
14581
            if (arg->ch == 's')
14582
                *p_str = PyObject_Str(v);
inline
                         
PyObject_Str will not be inlined into unicode_format_arg_format because its definition is unavailable 
unicode_format_arg_format
14583
            else if (arg->ch == 'r')
14584
                *p_str = PyObject_Repr(v);
inline
                         
PyObject_Repr will not be inlined into unicode_format_arg_format because its definition is unavailable 
unicode_format_arg_format
14585
            else
14586
                *p_str = PyObject_ASCII(v);
inline
                         
PyObject_ASCII will not be inlined into unicode_format_arg_format because its definition is unavailable 
unicode_format_arg_format
14587
        }
14588
        break;
14589
14590
    case 'i':
14591
    case 'd':
14592
    case 'u':
14593
    case 'o':
14594
    case 'x':
14595
    case 'X':
14596
    {
14597
        int ret = mainformatlong(v, arg, p_str, writer);
inline
                  
mainformatlong can be inlined into unicode_format_arg_format with cost=-14240 (threshold=250) 
unicode_format_arg_format
inline
                  
mainformatlong inlined into unicode_format_arg_format 
unicode_format_arg_format
14598
        if (ret != 0)
14599
            return ret;
14600
        arg->sign = 1;
14601
        break;
14602
    }
14603
14604
    case 'e':
14605
    case 'E':
14606
    case 'f':
14607
    case 'F':
14608
    case 'g':
14609
    case 'G':
14610
        if (arg->width == -1 && arg->prec == -1
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                     
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
                                     
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
14611
            && !(arg->flags & (F_SIGN | F_BLANK)))
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                      
load of type i32 eliminated in favor of phi 
unicode_format_arg
14612
        {
14613
            /* Fast path */
14614
            if (formatfloat(v, arg, NULL, writer) == -1)
inline
                
formatfloat too costly to inline (cost=565, threshold=250) 
unicode_format_arg_format
inline
                
formatfloat will not be inlined into unicode_format_arg_format 
unicode_format_arg_format
inline
                
formatfloat too costly to inline (cost=550, threshold=250) 
unicode_format_arg
inline
                
formatfloat will not be inlined into unicode_format_arg 
unicode_format_arg
inline
                
formatfloat too costly to inline (cost=280, threshold=250) 
PyUnicode_Format
inline
                
formatfloat will not be inlined into PyUnicode_Format 
PyUnicode_Format
14615
                return -1;
14616
            return 1;
14617
        }
14618
14619
        arg->sign = 1;
14620
        if (formatfloat(v, arg, p_str, NULL) == -1)
inline
            
formatfloat too costly to inline (cost=465, threshold=250) 
unicode_format_arg_format
inline
            
formatfloat will not be inlined into unicode_format_arg_format 
unicode_format_arg_format
inline
            
formatfloat too costly to inline (cost=445, threshold=250) 
unicode_format_arg
inline
            
formatfloat will not be inlined into unicode_format_arg 
unicode_format_arg
inline
            
formatfloat too costly to inline (cost=445, threshold=250) 
PyUnicode_Format
inline
            
formatfloat will not be inlined into PyUnicode_Format 
PyUnicode_Format
14621
            return -1;
14622
        break;
14623
14624
    case 'c':
14625
    {
14626
        Py_UCS4 ch = formatchar(v);
inline
                     
formatchar can be inlined into unicode_format_arg_format with cost=-14570 (threshold=250) 
unicode_format_arg_format
inline
                     
formatchar inlined into unicode_format_arg_format 
unicode_format_arg_format
14627
        if (ch == (Py_UCS4) -1)
14628
            return -1;
14629
        if (arg->width == -1 && arg->prec == -1) {
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                     
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                                     
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
                                     
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                     
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
14630
            /* Fast path */
14631
            if (_PyUnicodeWriter_WriteCharInline(writer, ch) < 0)
inline
                
_PyUnicodeWriter_WriteCharInline can be inlined into unicode_format_arg_format with cost=-14850 (threshold=325) 
unicode_format_arg_format
inline
                
_PyUnicodeWriter_WriteCharInline inlined into unicode_format_arg_format 
unicode_format_arg_format
14632
                return -1;
14633
            return 1;
14634
        }
14635
        *p_str = PyUnicode_FromOrdinal(ch);
inline
                 
PyUnicode_FromOrdinal too costly to inline (cost=365, threshold=250) 
unicode_format_arg_format
inline
                 
PyUnicode_FromOrdinal will not be inlined into unicode_format_arg_format 
unicode_format_arg_format
inline
                 
PyUnicode_FromOrdinal too costly to inline (cost=365, threshold=250) 
unicode_format_arg
inline
                 
PyUnicode_FromOrdinal will not be inlined into unicode_format_arg 
unicode_format_arg
inline
                 
PyUnicode_FromOrdinal too costly to inline (cost=365, threshold=250) 
PyUnicode_Format
inline
                 
PyUnicode_FromOrdinal will not be inlined into PyUnicode_Format 
PyUnicode_Format
14636
        break;
14637
    }
14638
14639
    default:
14640
        PyErr_Format(PyExc_ValueError,
inline
        
PyErr_Format will not be inlined into unicode_format_arg_format because its definition is unavailable 
unicode_format_arg_format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                     
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14641
                     "unsupported format character '%c' (0x%x) "
14642
                     "at index %zd",
14643
                     (31<=arg->ch && arg->ch<=126) ? (char)arg->ch : '?',
14644
                     (int)arg->ch,
14645
                     ctx->fmtpos - 1);
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
                          
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i64 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
14646
        return -1;
14647
    }
14648
    if (*p_str == NULL)
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_format
gvn
        
load eliminated by PRE 
unicode_format_arg_format
14649
        return -1;
14650
    assert (PyUnicode_Check(*p_str));
14651
    return 0;
14652
}
14653
14654
static int
14655
unicode_format_arg_output(struct unicode_formatter_t *ctx,
14656
                          struct unicode_format_arg_t *arg,
14657
                          PyObject *str)
14658
{
14659
    Py_ssize_t len;
14660
    enum PyUnicode_Kind kind;
14661
    void *pbuf;
14662
    Py_ssize_t pindex;
14663
    Py_UCS4 signchar;
14664
    Py_ssize_t buflen;
14665
    Py_UCS4 maxchar;
14666
    Py_ssize_t sublen;
14667
    _PyUnicodeWriter *writer = &ctx->writer;
14668
    Py_UCS4 fill;
14669
14670
    fill = ' ';
14671
    if (arg->sign && arg->flags & F_ZERO)
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
licm
             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                          
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14672
        fill = '0';
14673
14674
    if (PyUnicode_READY(str) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_format_arg_output
inline
        
_PyUnicode_Ready will not be inlined into unicode_format_arg_output 
unicode_format_arg_output
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_format_arg
inline
        
_PyUnicode_Ready will not be inlined into unicode_format_arg 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
PyUnicode_Format
inline
        
_PyUnicode_Ready will not be inlined into PyUnicode_Format 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
14675
        return -1;
14676
14677
    len = PyUnicode_GET_LENGTH(str);
gvn
          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
          
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
          
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
          
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
          
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
14678
    if ((arg->width == -1 || arg->width <= len)
gvn
              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
licm
              
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
              
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14679
        && (arg->prec == -1 || arg->prec >= len)
gvn
                 
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14680
        && !(arg->flags & (F_SIGN | F_BLANK)))
gvn
                  
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14681
    {
14682
        /* Fast path */
14683
        if (_PyUnicodeWriter_WriteStr(writer, str) == -1)
inline
            
_PyUnicodeWriter_WriteStr too costly to inline (cost=445, threshold=250) 
unicode_format_arg_output
inline
            
_PyUnicodeWriter_WriteStr will not be inlined into unicode_format_arg_output 
unicode_format_arg_output
inline
            
_PyUnicodeWriter_WriteStr too costly to inline (cost=445, threshold=250) 
unicode_format_arg
inline
            
_PyUnicodeWriter_WriteStr will not be inlined into unicode_format_arg 
unicode_format_arg
inline
            
_PyUnicodeWriter_WriteStr too costly to inline (cost=445, threshold=250) 
PyUnicode_Format
inline
            
_PyUnicodeWriter_WriteStr will not be inlined into PyUnicode_Format 
PyUnicode_Format
14684
            return -1;
14685
        return 0;
14686
    }
14687
14688
    /* Truncate the string for "s", "r" and "a" formats
14689
       if the precision is set */
14690
    if (arg->ch == 's' || arg->ch == 'r' || arg->ch == 'a') {
gvn
             
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
licm
             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
             
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
14691
        if (arg->prec >= 0 && len > arg->prec)
gvn
                 
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14692
            len = arg->prec;
14693
    }
14694
14695
    /* Adjust sign and width */
14696
    kind = PyUnicode_KIND(str);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_output
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Format
14697
    pbuf = PyUnicode_DATA(str);
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
           
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
14698
    pindex = 0;
14699
    signchar = '\0';
14700
    if (arg->sign) {
gvn
             
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_output
gvn
             
load of type i32 eliminated in favor of load 
unicode_format_arg
14701
        Py_UCS4 ch = PyUnicode_READ(kind, pbuf, pindex);
14702
        if (ch == '-' || ch == '+') {
14703
            signchar = ch;
14704
            len--;
14705
            pindex++;
14706
        }
14707
        else if (arg->flags & F_SIGN)
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14708
            signchar = '+';
14709
        else if (arg->flags & F_BLANK)
14710
            signchar = ' ';
14711
        else
14712
            arg->sign = 0;
14713
    }
14714
    if (arg->width < len)
gvn
             
load of type i64 eliminated in favor of load 
unicode_format_arg_output
14715
        arg->width = len;
14716
14717
    /* Prepare the writer */
14718
    maxchar = writer->maxchar;
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
licm
                      
hosting getelementptr 
PyUnicode_Format
licm
                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
14719
    if (!(arg->flags & F_LJUST)) {
gvn
               
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
licm
               
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
               
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14720
        if (arg->sign) {
gvn
                 
load of type i32 eliminated in favor of phi 
unicode_format_arg_output
14721
            if ((arg->width-1) > len)
14722
                maxchar = Py_MAX(maxchar, fill);
14723
        }
14724
        else {
14725
            if (arg->width > len)
14726
                maxchar = Py_MAX(maxchar, fill);
14727
        }
14728
    }
14729
    if (PyUnicode_MAX_CHAR_VALUE(str) > maxchar) {
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32 eliminated in favor of load 
unicode_format_arg
14730
        Py_UCS4 strmaxchar = _PyUnicode_FindMaxChar(str, 0, pindex+len);
inline
                             
_PyUnicode_FindMaxChar too costly to inline (cost=600, threshold=250) 
unicode_format_arg_output
inline
                             
_PyUnicode_FindMaxChar will not be inlined into unicode_format_arg_output 
unicode_format_arg_output
inline
                             
_PyUnicode_FindMaxChar too costly to inline (cost=600, threshold=250) 
unicode_format_arg
inline
                             
_PyUnicode_FindMaxChar will not be inlined into unicode_format_arg 
unicode_format_arg
inline
                             
_PyUnicode_FindMaxChar too costly to inline (cost=600, threshold=250) 
PyUnicode_Format
inline
                             
_PyUnicode_FindMaxChar will not be inlined into PyUnicode_Format 
PyUnicode_Format
14731
        maxchar = Py_MAX(maxchar, strmaxchar);
14732
    }
14733
14734
    buflen = arg->width;
gvn
                  
load of type i64 eliminated in favor of phi 
unicode_format_arg_output
14735
    if (arg->sign && len == arg->width)
gvn
             
load of type i32 eliminated in favor of phi 
unicode_format_arg_output
14736
        buflen++;
14737
    if (_PyUnicodeWriter_Prepare(writer, buflen, maxchar) == -1)
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
unicode_format_arg_output
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into unicode_format_arg_output 
unicode_format_arg_output
gvn
        
load of type i32 eliminated in favor of load 
unicode_format_arg_output
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=640, threshold=625) 
unicode_format_arg
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into unicode_format_arg 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
inline
        
_PyUnicodeWriter_PrepareInternal too costly to inline (cost=630, threshold=625) 
PyUnicode_Format
inline
        
_PyUnicodeWriter_PrepareInternal will not be inlined into PyUnicode_Format 
PyUnicode_Format
licm
        
hosting getelementptr 
PyUnicode_Format
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
14738
        return -1;
14739
14740
    /* Write the sign if needed */
14741
    if (arg->sign) {
gvn
             
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
             
load eliminated by PRE 
unicode_format_arg_output
14742
        if (fill != ' ') {
14743
            PyUnicode_WRITE(writer->kind, writer->data, writer->pos, signchar);
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
licm
            
hosting getelementptr 
PyUnicode_Format
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
            
hosting bitcast 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
14744
            writer->pos += 1;
gvn
                        
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                        
load eliminated by PRE 
unicode_format_arg_output
14745
        }
14746
        if (arg->width > len)
gvn
                 
load of type i64 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg_output
gvn
                 
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_output
gvn
                 
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                 
load eliminated by PRE 
unicode_format_arg
14747
            arg->width--;
14748
    }
14749
14750
    /* Write the numeric prefix for "x", "X" and "o" formats
14751
       if the alternate form is used.
14752
       For example, write "0x" for the "%#x" format. */
14753
    if ((arg->flags & F_ALT) && (arg->ch == 'x' || arg->ch == 'X' || arg->ch == 'o')) {
gvn
              
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg_output
gvn
              
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_output
gvn
                                      
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg_output
gvn
                                      
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_output
gvn
              
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                      
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
licm
              
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
                                      
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
              
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
              
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                      
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                      
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
14754
        assert(PyUnicode_READ(kind, pbuf, pindex) == '0');
14755
        assert(PyUnicode_READ(kind, pbuf, pindex + 1) == arg->ch);
14756
        if (fill != ' ') {
14757
            PyUnicode_WRITE(writer->kind, writer->data, writer->pos, '0');
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
licm
            
hosting getelementptr 
PyUnicode_Format
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
            
hosting bitcast 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
14758
            PyUnicode_WRITE(writer->kind, writer->data, writer->pos+1, arg->ch);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg_output
gvn
            
load eliminated by PRE 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
            
load eliminated by PRE 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
            
hosting getelementptr 
PyUnicode_Format
licm
            
hosting bitcast 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
14759
            writer->pos += 2;
gvn
                        
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                        
load eliminated by PRE 
unicode_format_arg_output
14760
            pindex += 2;
14761
        }
14762
        arg->width -= 2;
gvn
                   
load of type i64 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg_output
gvn
                   
load of type i64 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg_output
gvn
                   
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_output
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                   
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                   
load eliminated by PRE 
unicode_format_arg
14763
        if (arg->width < 0)
14764
            arg->width = 0;
14765
        len -= 2;
14766
    }
14767
14768
    /* Pad left with the fill character if needed */
14769
    if (arg->width > len && !(arg->flags & F_LJUST)) {
gvn
             
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_output
gvn
                                   
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                                   
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
             
load of type i64 eliminated in favor of phi 
unicode_format_arg
gvn
                                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
licm
                                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                   
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
14770
        sublen = arg->width - len;
14771
        FILL(writer->kind, writer->data, fill, writer->pos, sublen);
licm
        
hosting trunc 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
licm
        
hosting getelementptr 
PyUnicode_Format
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
        
hosting bitcast 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
loop-vectorize
        
vectorized loop (vectorization width: 8, interleaved count: 2) 
PyUnicode_Format
loop-vectorize
        
vectorized loop (vectorization width: 4, interleaved count: 2) 
PyUnicode_Format
loop-unroll
        
unrolled loop by a factor of 8 with run-time trip count 
PyUnicode_Format
14772
        writer->pos += sublen;
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
licm
                
hosting getelementptr 
PyUnicode_Format
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
14773
        arg->width = len;
14774
    }
14775
14776
    /* If padding with spaces: write sign if needed and/or numeric prefix if
14777
       the alternate form is used */
14778
    if (fill == ' ') {
14779
        if (arg->sign) {
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                 
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
licm
                 
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
14780
            PyUnicode_WRITE(writer->kind, writer->data, writer->pos, signchar);
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
licm
            
hosting getelementptr 
PyUnicode_Format
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
            
hosting bitcast 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
14781
            writer->pos += 1;
gvn
                        
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                        
load eliminated by PRE 
unicode_format_arg_output
14782
        }
14783
        if ((arg->flags & F_ALT) && (arg->ch == 'x' || arg->ch == 'X' || arg->ch == 'o')) {
gvn
                  
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                  
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                  
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                  
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                  
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg_output
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg_output
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg_output
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_output
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_output
gvn
                                          
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg_output
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                          
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                          
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                          
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                          
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
licm
                  
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
                                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                          
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                          
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                          
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                          
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                          
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                          
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
14784
            assert(PyUnicode_READ(kind, pbuf, pindex) == '0');
14785
            assert(PyUnicode_READ(kind, pbuf, pindex+1) == arg->ch);
14786
            PyUnicode_WRITE(writer->kind, writer->data, writer->pos, '0');
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
licm
            
hosting getelementptr 
PyUnicode_Format
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
            
hosting bitcast 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
14787
            PyUnicode_WRITE(writer->kind, writer->data, writer->pos+1, arg->ch);
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_format_arg_output
gvn
            
load eliminated by PRE 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
            
load eliminated by PRE 
unicode_format_arg
gvn
            
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
            
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
            
hosting getelementptr 
PyUnicode_Format
licm
            
hosting bitcast 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
14788
            writer->pos += 2;
gvn
                        
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                        
load eliminated by PRE 
unicode_format_arg_output
14789
            pindex += 2;
14790
        }
14791
    }
14792
14793
    /* Write characters */
14794
    if (len) {
14795
        _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos,
inline
        
_PyUnicode_FastCopyCharacters can be inlined into unicode_format_arg_output with cost=5 (threshold=375) 
unicode_format_arg_output
inline
        
_PyUnicode_FastCopyCharacters inlined into unicode_format_arg_output 
unicode_format_arg_output
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
licm
                                              
hosting getelementptr 
PyUnicode_Format
licm
                                              
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
                                                              
hosting getelementptr 
PyUnicode_Format
licm
                                                              
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                              
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                                                              
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
14796
                                      str, pindex, len);
14797
        writer->pos += len;
gvn
                    
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg_output
gvn
                    
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicode_format_arg
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Format
14798
    }
14799
14800
    /* Pad right with the fill character if needed */
14801
    if (arg->width > len) {
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
             
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
             
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
             
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
             
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
             
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
             
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
licm
             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
             
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
             
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
14802
        sublen = arg->width - len;
14803
        FILL(writer->kind, writer->data, ' ', writer->pos, sublen);
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
        
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg_output
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i32* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i16* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i8* not eliminated because it is clobbered by call 
unicode_format_arg
licm
        
hosting getelementptr 
PyUnicode_Format
licm
        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
        
hosting bitcast 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i32* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i16* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
loop-vectorize
        
vectorized loop (vectorization width: 8, interleaved count: 2) 
PyUnicode_Format
loop-vectorize
        
vectorized loop (vectorization width: 4, interleaved count: 2) 
PyUnicode_Format
loop-unroll
        
unrolled loop by a factor of 8 with run-time trip count 
PyUnicode_Format
14804
        writer->pos += sublen;
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg_output
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
licm
                
hosting getelementptr 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                    
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
14805
    }
14806
    return 0;
14807
}
14808
14809
/* Helper of PyUnicode_Format(): format one arg.
14810
   Return 0 on success, raise an exception and return -1 on error. */
14811
static int
14812
unicode_format_arg(struct unicode_formatter_t *ctx)
14813
{
14814
    struct unicode_format_arg_t arg;
licm
    
hosting bitcast 
PyUnicode_Format
14815
    PyObject *str;
licm
    
hosting bitcast 
PyUnicode_Format
14816
    int ret;
14817
14818
    arg.ch = PyUnicode_READ(ctx->fmtkind, ctx->fmtdata, ctx->fmtpos);
licm
             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
        
hosting getelementptr 
PyUnicode_Format
gvn
             
load of type i32 eliminated in favor of phi 
PyUnicode_Format
gvn
             
load of type i8* eliminated in favor of phi 
PyUnicode_Format
gvn
             
load of type i64 eliminated in favor of add 
PyUnicode_Format
gvn
             
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_Format
14819
    arg.flags = 0;
licm
        
hosting getelementptr 
PyUnicode_Format
14820
    arg.width = -1;
licm
        
hosting getelementptr 
PyUnicode_Format
14821
    arg.prec = -1;
licm
        
hosting getelementptr 
PyUnicode_Format
14822
    arg.sign = 0;
licm
        
hosting getelementptr 
PyUnicode_Format
14823
    str = NULL;
14824
14825
    ret = unicode_format_arg_parse(ctx, &arg);
inline
          
unicode_format_arg_parse can be inlined into unicode_format_arg with cost=-12670 (threshold=250) 
unicode_format_arg
inline
          
unicode_format_arg_parse inlined into unicode_format_arg 
unicode_format_arg
14826
    if (ret == -1)
14827
        return -1;
14828
14829
    ret = unicode_format_arg_format(ctx, &arg, &str);
inline
          
unicode_format_arg_format can be inlined into unicode_format_arg with cost=-12515 (threshold=250) 
unicode_format_arg
inline
          
unicode_format_arg_format inlined into unicode_format_arg 
unicode_format_arg
14830
    if (ret == -1)
14831
        return -1;
14832
14833
    if (ret != 1) {
14834
        ret = unicode_format_arg_output(ctx, &arg, str);
inline
              
unicode_format_arg_output can be inlined into unicode_format_arg with cost=-13190 (threshold=250) 
unicode_format_arg
inline
              
unicode_format_arg_output inlined into unicode_format_arg 
unicode_format_arg
gvn
                                                   
load of type %struct._object* eliminated in favor of phi 
unicode_format_arg
14835
        Py_DECREF(str);
gvn
        
load of type %struct._object* eliminated in favor of phi 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
14836
        if (ret == -1)
14837
            return -1;
14838
    }
14839
14840
    if (ctx->dict && (ctx->argidx < ctx->arglen) && arg.ch != '%') {
gvn
             
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
             
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                         
load of type i64 not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
unicode_format_arg
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by store 
unicode_format_arg
licm
             
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
                           
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
                                         
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
licm
                                                        
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                           
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                                        
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
             
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
14841
        PyErr_SetString(PyExc_TypeError,
inline
        
PyErr_SetString will not be inlined into unicode_format_arg because its definition is unavailable 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_format_arg
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14842
                        "not all arguments converted during string formatting");
14843
        return -1;
14844
    }
14845
    return 0;
14846
}
14847
14848
PyObject *
14849
PyUnicode_Format(PyObject *format, PyObject *args)
14850
{
14851
    struct unicode_formatter_t ctx;
14852
14853
    if (format == NULL || args == NULL) {
14854
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into PyUnicode_Format because its definition is unavailable 
PyUnicode_Format
14855
        return NULL;
14856
    }
14857
14858
    if (ensure_unicode(format) < 0)
inline
        
ensure_unicode can be inlined into PyUnicode_Format with cost=95 (threshold=250) 
PyUnicode_Format
inline
        
ensure_unicode inlined into PyUnicode_Format 
PyUnicode_Format
14859
        return NULL;
14860
14861
    ctx.fmtstr = format;
14862
    ctx.fmtdata = PyUnicode_DATA(ctx.fmtstr);
gvn
                  
load of type i32 not eliminated in favor of load because it is clobbered by call 
PyUnicode_Format
gvn
                  
load eliminated by PRE 
PyUnicode_Format
gvn
                  
load of type i8* not eliminated because it is clobbered by call 
PyUnicode_Format
14863
    ctx.fmtkind = PyUnicode_KIND(ctx.fmtstr);
gvn
                  
load of type %struct.PyASCIIObject* eliminated in favor of inttoptr 
PyUnicode_Format
gvn
                  
load of type i32 not eliminated because it is clobbered by store 
PyUnicode_Format
14864
    ctx.fmtcnt = PyUnicode_GET_LENGTH(ctx.fmtstr);
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                 
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
14865
    ctx.fmtpos = 0;
14866
14867
    _PyUnicodeWriter_Init(&ctx.writer);
inline
    
_PyUnicodeWriter_Init can be inlined into PyUnicode_Format with cost=-30 (threshold=375) 
PyUnicode_Format
inline
    
_PyUnicodeWriter_Init inlined into PyUnicode_Format 
PyUnicode_Format
14868
    ctx.writer.min_length = ctx.fmtcnt + 100;
gvn
                                
load of type i64 eliminated in favor of load 
PyUnicode_Format
14869
    ctx.writer.overallocate = 1;
14870
14871
    if (PyTuple_Check(args)) {
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
PyUnicode_Format
14872
        ctx.arglen = PyTuple_Size(args);
inline
                     
PyTuple_Size will not be inlined into PyUnicode_Format because its definition is unavailable 
PyUnicode_Format
14873
        ctx.argidx = 0;
14874
    }
14875
    else {
14876
        ctx.arglen = -1;
14877
        ctx.argidx = -2;
14878
    }
14879
    ctx.args_owned = 0;
14880
    if (PyMapping_Check(args) && !PyTuple_Check(args) && !PyUnicode_Check(args))
inline
        
PyMapping_Check will not be inlined into PyUnicode_Format because its definition is unavailable 
PyUnicode_Format
gvn
                                  
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
PyUnicode_Format
14881
        ctx.dict = args;
14882
    else
14883
        ctx.dict = NULL;
14884
    ctx.args = args;
14885
14886
    while (--ctx.fmtcnt >= 0) {
licm
           
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
           
load of type i64 eliminated in favor of load 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
           
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_Format
14887
        if (PyUnicode_READ(ctx.fmtkind, ctx.fmtdata, ctx.fmtpos) != '%') {
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load eliminated by PRE 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i8* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14888
            Py_ssize_t nonfmtpos;
14889
14890
            nonfmtpos = ctx.fmtpos++;
14891
            while (ctx.fmtcnt >= 0 &&
licm
                       
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                       
load of type i64 eliminated in favor of phi 
PyUnicode_Format
loop-vectorize
            
loop not vectorized: loop control flow is not understood by vectorizer 
PyUnicode_Format
loop-vectorize
            
loop not vectorized 
PyUnicode_Format
14892
                   PyUnicode_READ(ctx.fmtkind, ctx.fmtdata, ctx.fmtpos) != '%') {
licm
                   
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                   
load of type i32 eliminated in favor of phi 
PyUnicode_Format
gvn
                   
load of type i8* eliminated in favor of phi 
PyUnicode_Format
gvn
                   
load of type i64 eliminated in favor of phi 
PyUnicode_Format
gvn
                   
load of type i8 not eliminated because it is clobbered by store 
PyUnicode_Format
licm
                   
hosting icmp 
PyUnicode_Format
licm
                   
hosting bitcast 
PyUnicode_Format
14893
                ctx.fmtpos++;
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                          
load of type i64 eliminated in favor of phi 
PyUnicode_Format
14894
                ctx.fmtcnt--;
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                          
load of type i64 eliminated in favor of phi 
PyUnicode_Format
14895
            }
14896
            if (ctx.fmtcnt < 0) {
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                    
load of type i64 eliminated in favor of phi 
PyUnicode_Format
14897
                ctx.fmtpos--;
licm
                          
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                          
load of type i64 eliminated in favor of phi 
PyUnicode_Format
14898
                ctx.writer.overallocate = 0;
14899
            }
14900
14901
            if (_PyUnicodeWriter_WriteSubstring(&ctx.writer, ctx.fmtstr,
inline
                
_PyUnicodeWriter_WriteSubstring too costly to inline (cost=400, threshold=250) 
PyUnicode_Format
inline
                
_PyUnicodeWriter_WriteSubstring will not be inlined into PyUnicode_Format 
PyUnicode_Format
licm
                                                                 
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                                                 
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14902
                                                nonfmtpos, ctx.fmtpos) < 0)
licm
                                                               
failed to move load with loop-invariant address because the loop may invalidate its value 
PyUnicode_Format
gvn
                                                               
load of type i64 eliminated in favor of phi 
PyUnicode_Format
14903
                goto onError;
14904
        }
14905
        else {
14906
            ctx.fmtpos++;
14907
            if (unicode_format_arg(&ctx) == -1)
inline
                
unicode_format_arg can be inlined into PyUnicode_Format with cost=-7310 (threshold=250) 
PyUnicode_Format
inline
                
unicode_format_arg inlined into PyUnicode_Format 
PyUnicode_Format
14908
                goto onError;
14909
        }
14910
    }
14911
14912
    if (ctx.argidx < ctx.arglen && !ctx.dict) {
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load eliminated by PRE 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load of type i64 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                         
load eliminated by PRE 
PyUnicode_Format
gvn
                                        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
                                        
load eliminated by PRE 
PyUnicode_Format
14913
        PyErr_SetString(PyExc_TypeError,
inline
        
PyErr_SetString will not be inlined into PyUnicode_Format because its definition is unavailable 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
gvn
                        
load of type %struct._object* not eliminated because it is clobbered by call 
PyUnicode_Format
14914
                        "not all arguments converted during string formatting");
14915
        goto onError;
14916
    }
14917
14918
    if (ctx.args_owned) {
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14919
        Py_DECREF(ctx.args);
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14920
    }
14921
    return _PyUnicodeWriter_Finish(&ctx.writer);
inline
           
_PyUnicodeWriter_Finish too costly to inline (cost=270, threshold=250) 
PyUnicode_Format
inline
           
_PyUnicodeWriter_Finish will not be inlined into PyUnicode_Format 
PyUnicode_Format
14922
14923
  onError:
14924
    _PyUnicodeWriter_Dealloc(&ctx.writer);
inline
    
_PyUnicodeWriter_Dealloc can be inlined into PyUnicode_Format with cost=20 (threshold=250) 
PyUnicode_Format
inline
    
_PyUnicodeWriter_Dealloc inlined into PyUnicode_Format 
PyUnicode_Format
14925
    if (ctx.args_owned) {
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
            
load of type i32 not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14926
        Py_DECREF(ctx.args);
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by store 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_Format
14927
    }
14928
    return NULL;
14929
}
14930
14931
static PyObject *
14932
unicode_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
14933
14934
static PyObject *
14935
unicode_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
14936
{
14937
    PyObject *x = NULL;
14938
    static char *kwlist[] = {"object", "encoding", "errors", 0};
14939
    char *encoding = NULL;
14940
    char *errors = NULL;
14941
14942
    if (type != &PyUnicode_Type)
14943
        return unicode_subtype_new(type, args, kwds);
inline
               
unicode_subtype_new can be inlined into unicode_new with cost=-14295 (threshold=250) 
unicode_new
inline
               
unicode_subtype_new inlined into unicode_new 
unicode_new
14944
    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oss:str",
inline
         
_PyArg_ParseTupleAndKeywords_SizeT will not be inlined into unicode_new because its definition is unavailable 
unicode_new
14945
                                     kwlist, &x, &encoding, &errors))
14946
        return NULL;
14947
    if (x == NULL)
gvn
        
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
unicode_new
14948
        _Py_RETURN_UNICODE_EMPTY();
inline
        
PyUnicode_New too costly to inline (cost=290, threshold=250) 
unicode_new
inline
        
PyUnicode_New will not be inlined into unicode_new 
unicode_new
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
unicode_new
gvn
        
load of type %struct._object* eliminated in favor of phi 
unicode_new
14949
    if (encoding == NULL && errors == NULL)
gvn
        
load of type i8* not eliminated in favor of store because it is clobbered by call 
unicode_new
gvn
                            
load of type i8* not eliminated in favor of store because it is clobbered by call 
unicode_new
14950
        return PyObject_Str(x);
inline
               
PyObject_Str will not be inlined into unicode_new because its definition is unavailable 
unicode_new
14951
    else
14952
        return PyUnicode_FromEncodedObject(x, encoding, errors);
inline
               
PyUnicode_FromEncodedObject too costly to inline (cost=535, threshold=250) 
unicode_new
inline
               
PyUnicode_FromEncodedObject will not be inlined into unicode_new 
unicode_new
14953
}
14954
14955
static PyObject *
14956
unicode_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
14957
{
14958
    PyObject *unicode, *self;
14959
    Py_ssize_t length, char_size;
14960
    int share_wstr, share_utf8;
14961
    unsigned int kind;
14962
    void *data;
14963
14964
    assert(PyType_IsSubtype(type, &PyUnicode_Type));
14965
14966
    unicode = unicode_new(&PyUnicode_Type, args, kwds);
inline
              
unicode_new too costly to inline (cost=280, threshold=250) 
unicode_subtype_new
inline
              
unicode_new will not be inlined into unicode_subtype_new 
unicode_subtype_new
inline
              
unicode_new too costly to inline (cost=280, threshold=250) 
unicode_new
inline
              
unicode_new will not be inlined into unicode_new 
unicode_new
14967
    if (unicode == NULL)
14968
        return NULL;
14969
    assert(_PyUnicode_CHECK(unicode));
14970
    if (PyUnicode_READY(unicode) == -1) {
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_subtype_new
inline
        
_PyUnicode_Ready will not be inlined into unicode_subtype_new 
unicode_subtype_new
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_new
inline
        
_PyUnicode_Ready will not be inlined into unicode_new 
unicode_new
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
        
load of type i32 not eliminated because it is clobbered by call 
unicode_new
14971
        Py_DECREF(unicode);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_new
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_new
14972
        return NULL;
14973
    }
14974
14975
    self = type->tp_alloc(type, 0);
gvn
                 
load of type %struct._object* (%struct._typeobject*, i64)* not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
                 
load of type %struct._object* (%struct._typeobject*, i64)* not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
                 
load of type %struct._object* (%struct._typeobject*, i64)* not eliminated because it is clobbered by call 
unicode_new
gvn
                 
load of type %struct._object* (%struct._typeobject*, i64)* not eliminated because it is clobbered by call 
unicode_new
14976
    if (self == NULL) {
14977
        Py_DECREF(unicode);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
        
load of type i64 not eliminated because it is clobbered by call 
unicode_new
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_new
14978
        return NULL;
14979
    }
14980
    kind = PyUnicode_KIND(unicode);
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_subtype_new
gvn
           
load of type i32 not eliminated in favor of load because it is clobbered by call 
unicode_new
14981
    length = PyUnicode_GET_LENGTH(unicode);
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
             
load of type i64 not eliminated because it is clobbered by call 
unicode_new
14982
14983
    _PyUnicode_LENGTH(self) = length;
14984
#ifdef Py_DEBUG
14985
    _PyUnicode_HASH(self) = -1;
14986
#else
14987
    _PyUnicode_HASH(self) = _PyUnicode_HASH(unicode);
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
                            
load of type i64 not eliminated because it is clobbered by call 
unicode_new
14988
#endif
14989
    _PyUnicode_STATE(self).interned = 0;
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
                                    
load of type i32 not eliminated because it is clobbered by call 
unicode_new
14990
    _PyUnicode_STATE(self).kind = kind;
14991
    _PyUnicode_STATE(self).compact = 0;
14992
    _PyUnicode_STATE(self).ascii = _PyUnicode_STATE(unicode).ascii;
gvn
                                                             
load of type i32 not eliminated because it is clobbered by store 
unicode_subtype_new
gvn
                                                             
load of type i32 not eliminated because it is clobbered by store 
unicode_new
14993
    _PyUnicode_STATE(self).ready = 1;
14994
    _PyUnicode_WSTR(self) = NULL;
14995
    _PyUnicode_UTF8_LENGTH(self) = 0;
14996
    _PyUnicode_UTF8(self) = NULL;
14997
    _PyUnicode_WSTR_LENGTH(self) = 0;
14998
    _PyUnicode_DATA_ANY(self) = NULL;
14999
15000
    share_utf8 = 0;
15001
    share_wstr = 0;
15002
    if (kind == PyUnicode_1BYTE_KIND) {
15003
        char_size = 1;
15004
        if (PyUnicode_MAX_CHAR_VALUE(unicode) < 128)
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_subtype_new
gvn
            
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_new
15005
            share_utf8 = 1;
15006
    }
15007
    else if (kind == PyUnicode_2BYTE_KIND) {
15008
        char_size = 2;
15009
        if (sizeof(wchar_t) == 2)
15010
            share_wstr = 1;
15011
    }
15012
    else {
15013
        assert(kind == PyUnicode_4BYTE_KIND);
15014
        char_size = 4;
15015
        if (sizeof(wchar_t) == 4)
15016
            share_wstr = 1;
15017
    }
15018
15019
    /* Ensure we won't overflow the length. */
15020
    if (length > (PY_SSIZE_T_MAX / char_size - 1)) {
15021
        PyErr_NoMemory();
inline
        
PyErr_NoMemory will not be inlined into unicode_subtype_new because its definition is unavailable 
unicode_subtype_new
15022
        goto onError;
15023
    }
15024
    data = PyObject_MALLOC((length + 1) * char_size);
inline
           
PyObject_Malloc will not be inlined into unicode_subtype_new because its definition is unavailable 
unicode_subtype_new
15025
    if (data == NULL) {
15026
        PyErr_NoMemory();
inline
        
PyErr_NoMemory will not be inlined into unicode_subtype_new because its definition is unavailable 
unicode_subtype_new
15027
        goto onError;
15028
    }
15029
15030
    _PyUnicode_DATA_ANY(self) = data;
15031
    if (share_utf8) {
15032
        _PyUnicode_UTF8_LENGTH(self) = length;
15033
        _PyUnicode_UTF8(self) = data;
15034
    }
15035
    if (share_wstr) {
15036
        _PyUnicode_WSTR_LENGTH(self) = length;
15037
        _PyUnicode_WSTR(self) = (wchar_t *)data;
15038
    }
15039
15040
    memcpy(data, PyUnicode_DATA(unicode),
gvn
                 
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_subtype_new
gvn
                 
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_subtype_new
gvn
                 
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_subtype_new
gvn
                 
load of type i8* not eliminated because it is clobbered by store 
unicode_subtype_new
gvn
                 
load of type i8* not eliminated because it is clobbered by store 
unicode_subtype_new
gvn
                 
load of type i8* not eliminated because it is clobbered by store 
unicode_subtype_new
gvn
                 
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_new
gvn
                 
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_new
gvn
                 
load of type i32 not eliminated in favor of load because it is clobbered by store 
unicode_new
gvn
                 
load of type i8* not eliminated because it is clobbered by store 
unicode_new
gvn
                 
load of type i8* not eliminated because it is clobbered by store 
unicode_new
gvn
                 
load of type i8* not eliminated because it is clobbered by store 
unicode_new
15041
              kind * (length + 1));
15042
    assert(_PyUnicode_CheckConsistency(self, 1));
15043
#ifdef Py_DEBUG
15044
    _PyUnicode_HASH(self) = _PyUnicode_HASH(unicode);
15045
#endif
15046
    Py_DECREF(unicode);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_new
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_new
15047
    return self;
15048
15049
onError:
15050
    Py_DECREF(unicode);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_new
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_new
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_new
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_new
15051
    Py_DECREF(self);
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_subtype_new
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_subtype_new
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_new
gvn
    
load of type i64 not eliminated because it is clobbered by store 
unicode_new
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_new
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_new
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
unicode_new
15052
    return NULL;
15053
}
15054
15055
PyDoc_STRVAR(unicode_doc,
15056
"str(object='') -> str\n\
15057
str(bytes_or_buffer[, encoding[, errors]]) -> str\n\
15058
\n\
15059
Create a new string object from the given object. If encoding or\n\
15060
errors is specified, then the object must expose a data buffer\n\
15061
that will be decoded using the given encoding and error handler.\n\
15062
Otherwise, returns the result of object.__str__() (if defined)\n\
15063
or repr(object).\n\
15064
encoding defaults to sys.getdefaultencoding().\n\
15065
errors defaults to 'strict'.");
15066
15067
static PyObject *unicode_iter(PyObject *seq);
15068
15069
PyTypeObject PyUnicode_Type = {
15070
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
15071
    "str",              /* tp_name */
15072
    sizeof(PyUnicodeObject),        /* tp_size */
15073
    0,                  /* tp_itemsize */
15074
    /* Slots */
15075
    (destructor)unicode_dealloc,    /* tp_dealloc */
15076
    0,                  /* tp_print */
15077
    0,                  /* tp_getattr */
15078
    0,                  /* tp_setattr */
15079
    0,                  /* tp_reserved */
15080
    unicode_repr,           /* tp_repr */
15081
    &unicode_as_number,         /* tp_as_number */
15082
    &unicode_as_sequence,       /* tp_as_sequence */
15083
    &unicode_as_mapping,        /* tp_as_mapping */
15084
    (hashfunc) unicode_hash,        /* tp_hash*/
15085
    0,                  /* tp_call*/
15086
    (reprfunc) unicode_str,     /* tp_str */
15087
    PyObject_GenericGetAttr,        /* tp_getattro */
15088
    0,                  /* tp_setattro */
15089
    0,                  /* tp_as_buffer */
15090
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
15091
    Py_TPFLAGS_UNICODE_SUBCLASS,    /* tp_flags */
15092
    unicode_doc,            /* tp_doc */
15093
    0,                  /* tp_traverse */
15094
    0,                  /* tp_clear */
15095
    PyUnicode_RichCompare,      /* tp_richcompare */
15096
    0,                  /* tp_weaklistoffset */
15097
    unicode_iter,           /* tp_iter */
15098
    0,                  /* tp_iternext */
15099
    unicode_methods,            /* tp_methods */
15100
    0,                  /* tp_members */
15101
    0,                  /* tp_getset */
15102
    &PyBaseObject_Type,         /* tp_base */
15103
    0,                  /* tp_dict */
15104
    0,                  /* tp_descr_get */
15105
    0,                  /* tp_descr_set */
15106
    0,                  /* tp_dictoffset */
15107
    0,                  /* tp_init */
15108
    0,                  /* tp_alloc */
15109
    unicode_new,            /* tp_new */
15110
    PyObject_Del,           /* tp_free */
15111
};
15112
15113
/* Initialize the Unicode implementation */
15114
15115
int _PyUnicode_Init(void)
15116
{
15117
    /* XXX - move this array to unicodectype.c ? */
15118
    Py_UCS2 linebreak[] = {
15119
        0x000A, /* LINE FEED */
15120
        0x000D, /* CARRIAGE RETURN */
15121
        0x001C, /* FILE SEPARATOR */
15122
        0x001D, /* GROUP SEPARATOR */
15123
        0x001E, /* RECORD SEPARATOR */
15124
        0x0085, /* NEXT LINE */
15125
        0x2028, /* LINE SEPARATOR */
15126
        0x2029, /* PARAGRAPH SEPARATOR */
15127
    };
15128
15129
    /* Init the implementation */
15130
    _Py_INCREF_UNICODE_EMPTY();
inline
    
PyUnicode_New too costly to inline (cost=290, threshold=250) 
_PyUnicode_Init
inline
    
PyUnicode_New will not be inlined into _PyUnicode_Init 
_PyUnicode_Init
15131
    if (!unicode_empty)
15132
        Py_FatalError("Can't create empty string");
inline
        
Py_FatalError will not be inlined into _PyUnicode_Init because its definition is unavailable 
_PyUnicode_Init
15133
    Py_DECREF(unicode_empty);
gvn
    
load of type i64 eliminated in favor of add 
_PyUnicode_Init
15134
15135
    if (PyType_Ready(&PyUnicode_Type) < 0)
inline
        
PyType_Ready will not be inlined into _PyUnicode_Init because its definition is unavailable 
_PyUnicode_Init
15136
        Py_FatalError("Can't initialize 'unicode'");
inline
        
Py_FatalError will not be inlined into _PyUnicode_Init because its definition is unavailable 
_PyUnicode_Init
15137
15138
    /* initialize the linebreak bloom filter */
15139
    bloom_linebreak = make_bloom_mask(
inline
                      
make_bloom_mask can be inlined into _PyUnicode_Init with cost=-15000 (threshold=325) 
_PyUnicode_Init
inline
                      
make_bloom_mask inlined into _PyUnicode_Init 
_PyUnicode_Init
15140
        PyUnicode_2BYTE_KIND, linebreak,
15141
        Py_ARRAY_LENGTH(linebreak));
15142
15143
    if (PyType_Ready(&EncodingMapType) < 0)
inline
        
PyType_Ready will not be inlined into _PyUnicode_Init because its definition is unavailable 
_PyUnicode_Init
15144
         Py_FatalError("Can't initialize encoding map type");
inline
         
Py_FatalError will not be inlined into _PyUnicode_Init because its definition is unavailable 
_PyUnicode_Init
15145
15146
    if (PyType_Ready(&PyFieldNameIter_Type) < 0)
inline
        
PyType_Ready will not be inlined into _PyUnicode_Init because its definition is unavailable 
_PyUnicode_Init
15147
        Py_FatalError("Can't initialize field name iterator type");
inline
        
Py_FatalError will not be inlined into _PyUnicode_Init because its definition is unavailable 
_PyUnicode_Init
15148
15149
    if (PyType_Ready(&PyFormatterIter_Type) < 0)
inline
        
PyType_Ready will not be inlined into _PyUnicode_Init because its definition is unavailable 
_PyUnicode_Init
15150
        Py_FatalError("Can't initialize formatter iter type");
inline
        
Py_FatalError will not be inlined into _PyUnicode_Init because its definition is unavailable 
_PyUnicode_Init
15151
15152
    return 0;
15153
}
15154
15155
/* Finalize the Unicode implementation */
15156
15157
int
15158
PyUnicode_ClearFreeList(void)
15159
{
15160
    return 0;
15161
}
15162
15163
void
15164
_PyUnicode_Fini(void)
15165
{
15166
    int i;
15167
15168
    Py_CLEAR(unicode_empty);
15169
15170
    for (i = 0; i < 256; i++)
loop-vectorize
    
loop not vectorized 
_PyUnicode_Fini
15171
        Py_CLEAR(unicode_latin1[i]);
gvn
        
load of type %struct._object* not eliminated because it is clobbered by call 
_PyUnicode_Fini
loop-vectorize
        
loop not vectorized: control flow cannot be substituted for a select 
_PyUnicode_Fini
15172
    _PyUnicode_ClearStaticStrings();
inline
    
_PyUnicode_ClearStaticStrings can be inlined into _PyUnicode_Fini with cost=75 (threshold=250) 
_PyUnicode_Fini
inline
    
_PyUnicode_ClearStaticStrings inlined into _PyUnicode_Fini 
_PyUnicode_Fini
15173
    (void)PyUnicode_ClearFreeList();
15174
}
15175
15176
void
15177
PyUnicode_InternInPlace(PyObject **p)
15178
{
15179
    PyObject *s = *p;
15180
    PyObject *t;
15181
#ifdef Py_DEBUG
15182
    assert(s != NULL);
15183
    assert(_PyUnicode_CHECK(s));
15184
#else
15185
    if (s == NULL || !PyUnicode_Check(s))
15186
        return;
15187
#endif
15188
    /* If it's a subclass, we don't really know what putting
15189
       it in the interned dict might do. */
15190
    if (!PyUnicode_CheckExact(s))
15191
        return;
15192
    if (PyUnicode_CHECK_INTERNED(s))
15193
        return;
15194
    if (interned == NULL) {
15195
        interned = PyDict_New();
inline
                   
PyDict_New will not be inlined into PyUnicode_InternInPlace because its definition is unavailable 
PyUnicode_InternInPlace
15196
        if (interned == NULL) {
15197
            PyErr_Clear(); /* Don't leave an exception */
inline
            
PyErr_Clear will not be inlined into PyUnicode_InternInPlace because its definition is unavailable 
PyUnicode_InternInPlace
15198
            return;
15199
        }
15200
    }
15201
    Py_ALLOW_RECURSION
15202
    t = PyDict_SetDefault(interned, s, s);
inline
        
PyDict_SetDefault will not be inlined into PyUnicode_InternInPlace because its definition is unavailable 
PyUnicode_InternInPlace
gvn
                          
load of type %struct._object* eliminated in favor of phi 
PyUnicode_InternInPlace
15203
    Py_END_ALLOW_RECURSION
15204
    if (t == NULL) {
15205
        PyErr_Clear();
inline
        
PyErr_Clear will not be inlined into PyUnicode_InternInPlace because its definition is unavailable 
PyUnicode_InternInPlace
15206
        return;
15207
    }
15208
    if (t != s) {
15209
        Py_INCREF(t);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_InternInPlace
15210
        Py_SETREF(*p, t);
gvn
        
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
PyUnicode_InternInPlace
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_InternInPlace
gvn
        
load of type %struct._typeobject* not eliminated because it is clobbered by store 
PyUnicode_InternInPlace
15211
        return;
15212
    }
15213
    /* The two references in interned are not counted by refcnt.
15214
       The deallocator will take care of this */
15215
    Py_REFCNT(s) -= 2;
gvn
                 
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_InternInPlace
15216
    _PyUnicode_STATE(s).interned = SSTATE_INTERNED_MORTAL;
gvn
                                 
load of type i32 not eliminated in favor of load because it is clobbered by store 
PyUnicode_InternInPlace
15217
}
15218
15219
void
15220
PyUnicode_InternImmortal(PyObject **p)
15221
{
15222
    PyUnicode_InternInPlace(p);
inline
    
PyUnicode_InternInPlace too costly to inline (cost=355, threshold=250) 
PyUnicode_InternImmortal
inline
    
PyUnicode_InternInPlace will not be inlined into PyUnicode_InternImmortal 
PyUnicode_InternImmortal
15223
    if (PyUnicode_CHECK_INTERNED(*p) != SSTATE_INTERNED_IMMORTAL) {
gvn
        
load of type %struct.PyASCIIObject* not eliminated because it is clobbered by call 
PyUnicode_InternImmortal
gvn
        
load of type i32 not eliminated because it is clobbered by call 
PyUnicode_InternImmortal
15224
        _PyUnicode_STATE(*p).interned = SSTATE_INTERNED_IMMORTAL;
15225
        Py_INCREF(*p);
gvn
        
load of type %struct._object* not eliminated because it is clobbered by store 
PyUnicode_InternImmortal
gvn
        
load of type i64 not eliminated because it is clobbered by store 
PyUnicode_InternImmortal
15226
    }
15227
}
15228
15229
PyObject *
15230
PyUnicode_InternFromString(const char *cp)
15231
{
15232
    PyObject *s = PyUnicode_FromString(cp);
inline
                  
PyUnicode_FromString can be inlined into PyUnicode_InternFromString with cost=105 (threshold=250) 
PyUnicode_InternFromString
inline
                  
PyUnicode_FromString inlined into PyUnicode_InternFromString 
PyUnicode_InternFromString
15233
    if (s == NULL)
15234
        return NULL;
15235
    PyUnicode_InternInPlace(&s);
inline
    
PyUnicode_InternInPlace too costly to inline (cost=340, threshold=250) 
PyUnicode_InternFromString
inline
    
PyUnicode_InternInPlace will not be inlined into PyUnicode_InternFromString 
PyUnicode_InternFromString
15236
    return s;
gvn
           
load of type %struct._object* not eliminated in favor of store because it is clobbered by call 
PyUnicode_InternFromString
15237
}
15238
15239
void
15240
_Py_ReleaseInternedUnicodeStrings(void)
15241
{
15242
    PyObject *keys;
15243
    PyObject *s;
15244
    Py_ssize_t i, n;
15245
    Py_ssize_t immortal_size = 0, mortal_size = 0;
15246
15247
    if (interned == NULL || !PyDict_Check(interned))
15248
        return;
15249
    keys = PyDict_Keys(interned);
inline
           
PyDict_Keys will not be inlined into _Py_ReleaseInternedUnicodeStrings because its definition is unavailable 
_Py_ReleaseInternedUnicodeStrings
15250
    if (keys == NULL || !PyList_Check(keys)) {
gvn
                         
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15251
        PyErr_Clear();
inline
        
PyErr_Clear will not be inlined into _Py_ReleaseInternedUnicodeStrings because its definition is unavailable 
_Py_ReleaseInternedUnicodeStrings
15252
        return;
15253
    }
15254
15255
    /* Since _Py_ReleaseInternedUnicodeStrings() is intended to help a leak
15256
       detector, interned unicode strings are not forcibly deallocated;
15257
       rather, we give them their stolen references back, and then clear
15258
       and DECREF the interned dict. */
15259
15260
    n = PyList_GET_SIZE(keys);
gvn
        
load of type i64 not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15261
    fprintf(stderr, "releasing %" PY_FORMAT_SIZE_T "d interned strings\n",
inline
    
fprintf will not be inlined into _Py_ReleaseInternedUnicodeStrings because its definition is unavailable 
_Py_ReleaseInternedUnicodeStrings
gvn
            
load of type %struct._IO_FILE* not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15262
            n);
15263
    for (i = 0; i < n; i++) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
_Py_ReleaseInternedUnicodeStrings
loop-vectorize
    
loop not vectorized 
_Py_ReleaseInternedUnicodeStrings
15264
        s = PyList_GET_ITEM(keys, i);
licm
            
hosting getelementptr 
_Py_ReleaseInternedUnicodeStrings
licm
            
hosting bitcast 
_Py_ReleaseInternedUnicodeStrings
licm
            
failed to move load with loop-invariant address because the loop may invalidate its value 
_Py_ReleaseInternedUnicodeStrings
gvn
            
load of type %struct._object** not eliminated because it is clobbered by store 
_Py_ReleaseInternedUnicodeStrings
gvn
            
load of type %struct._object** not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15265
        if (PyUnicode_READY(s) == -1) {
inline
            
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
_Py_ReleaseInternedUnicodeStrings
inline
            
_PyUnicode_Ready will not be inlined into _Py_ReleaseInternedUnicodeStrings 
_Py_ReleaseInternedUnicodeStrings
15266
            assert(0 && "could not ready string");
15267
            fprintf(stderr, "could not ready string\n");
inline
            
fwrite will not be inlined into _Py_ReleaseInternedUnicodeStrings because its definition is unavailable 
_Py_ReleaseInternedUnicodeStrings
licm
                    
failed to move load with loop-invariant address because the loop may invalidate its value 
_Py_ReleaseInternedUnicodeStrings
gvn
                    
load of type %struct._IO_FILE* not eliminated in favor of load because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15268
        }
15269
        switch (PyUnicode_CHECK_INTERNED(s)) {
gvn
                
load of type i32 not eliminated in favor of load because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
gvn
                
load of type i32 not eliminated in favor of load because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15270
        case SSTATE_NOT_INTERNED:
15271
            /* XXX Shouldn't happen */
15272
            break;
15273
        case SSTATE_INTERNED_IMMORTAL:
15274
            Py_REFCNT(s) += 1;
gvn
                         
load of type i64 not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
gvn
                         
load of type i64 not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15275
            immortal_size += PyUnicode_GET_LENGTH(s);
gvn
                             
load of type i64 not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
gvn
                             
load of type i64 not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15276
            break;
15277
        case SSTATE_INTERNED_MORTAL:
15278
            Py_REFCNT(s) += 2;
gvn
                         
load of type i64 not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
gvn
                         
load of type i64 not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15279
            mortal_size += PyUnicode_GET_LENGTH(s);
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
gvn
                           
load of type i64 not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15280
            break;
15281
        default:
15282
            Py_FatalError("Inconsistent interned string state.");
inline
            
Py_FatalError will not be inlined into _Py_ReleaseInternedUnicodeStrings because its definition is unavailable 
_Py_ReleaseInternedUnicodeStrings
15283
        }
15284
        _PyUnicode_STATE(s).interned = SSTATE_NOT_INTERNED;
15285
    }
15286
    fprintf(stderr, "total size of all interned strings: "
inline
    
fprintf will not be inlined into _Py_ReleaseInternedUnicodeStrings because its definition is unavailable 
_Py_ReleaseInternedUnicodeStrings
gvn
            
load of type %struct._IO_FILE* not eliminated in favor of load because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
gvn
            
load of type %struct._IO_FILE* not eliminated in favor of load because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
gvn
            
load of type %struct._IO_FILE* not eliminated in favor of load because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15287
            "%" PY_FORMAT_SIZE_T "d/%" PY_FORMAT_SIZE_T "d "
15288
            "mortal/immortal\n", mortal_size, immortal_size);
15289
    Py_DECREF(keys);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
gvn
    
load of type %struct._typeobject* not eliminated in favor of load because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15290
    PyDict_Clear(interned);
inline
    
PyDict_Clear will not be inlined into _Py_ReleaseInternedUnicodeStrings because its definition is unavailable 
_Py_ReleaseInternedUnicodeStrings
gvn
                 
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
gvn
                 
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15291
    Py_CLEAR(interned);
gvn
    
load of type %struct._object* not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
gvn
    
load of type i64 not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
gvn
    
load of type %struct._typeobject* not eliminated because it is clobbered by call 
_Py_ReleaseInternedUnicodeStrings
15292
}
15293
15294
15295
/********************* Unicode Iterator **************************/
15296
15297
typedef struct {
15298
    PyObject_HEAD
15299
    Py_ssize_t it_index;
15300
    PyObject *it_seq;    /* Set to NULL when iterator is exhausted */
15301
} unicodeiterobject;
15302
15303
static void
15304
unicodeiter_dealloc(unicodeiterobject *it)
15305
{
15306
    _PyObject_GC_UNTRACK(it);
gvn
    
load of type %struct.anon.1* not eliminated because it is clobbered by store 
unicodeiter_dealloc
15307
    Py_XDECREF(it->it_seq);
15308
    PyObject_GC_Del(it);
inline
    
PyObject_GC_Del will not be inlined into unicodeiter_dealloc because its definition is unavailable 
unicodeiter_dealloc
15309
}
15310
15311
static int
15312
unicodeiter_traverse(unicodeiterobject *it, visitproc visit, void *arg)
15313
{
15314
    Py_VISIT(it->it_seq);
15315
    return 0;
15316
}
15317
15318
static PyObject *
15319
unicodeiter_next(unicodeiterobject *it)
15320
{
15321
    PyObject *seq, *item;
15322
15323
    assert(it != NULL);
15324
    seq = it->it_seq;
15325
    if (seq == NULL)
15326
        return NULL;
15327
    assert(_PyUnicode_CHECK(seq));
15328
15329
    if (it->it_index < PyUnicode_GET_LENGTH(seq)) {
15330
        int kind = PyUnicode_KIND(seq);
15331
        void *data = PyUnicode_DATA(seq);
15332
        Py_UCS4 chr = PyUnicode_READ(kind, data, it->it_index);
gvn
                      
load of type i64 eliminated in favor of load 
unicodeiter_next
15333
        item = PyUnicode_FromOrdinal(chr);
inline
               
PyUnicode_FromOrdinal too costly to inline (cost=365, threshold=250) 
unicodeiter_next
inline
               
PyUnicode_FromOrdinal will not be inlined into unicodeiter_next 
unicodeiter_next
15334
        if (item != NULL)
15335
            ++it->it_index;
gvn
            
load of type i64 not eliminated in favor of load because it is clobbered by call 
unicodeiter_next
15336
        return item;
15337
    }
15338
15339
    it->it_seq = NULL;
15340
    Py_DECREF(seq);
15341
    return NULL;
15342
}
15343
15344
static PyObject *
15345
unicodeiter_len(unicodeiterobject *it)
15346
{
15347
    Py_ssize_t len = 0;
15348
    if (it->it_seq)
15349
        len = PyUnicode_GET_LENGTH(it->it_seq) - it->it_index;
15350
    return PyLong_FromSsize_t(len);
inline
           
PyLong_FromSsize_t will not be inlined into unicodeiter_len because its definition is unavailable 
unicodeiter_len
15351
}
15352
15353
PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
15354
15355
static PyObject *
15356
unicodeiter_reduce(unicodeiterobject *it)
15357
{
15358
    if (it->it_seq != NULL) {
15359
        return Py_BuildValue("N(O)n", _PyObject_GetBuiltin("iter"),
inline
                                      
_PyObject_GetBuiltin will not be inlined into unicodeiter_reduce because its definition is unavailable 
unicodeiter_reduce
inline
               
_Py_BuildValue_SizeT will not be inlined into unicodeiter_reduce because its definition is unavailable 
unicodeiter_reduce
15360
                             it->it_seq, it->it_index);
gvn
                                 
load of type %struct._object* not eliminated in favor of load because it is clobbered by call 
unicodeiter_reduce
gvn
                                             
load of type i64 not eliminated because it is clobbered by call 
unicodeiter_reduce
15361
    } else {
15362
        PyObject *u = PyUnicode_FromUnicode(NULL, 0);
inline
                      
PyUnicode_FromUnicode can be inlined into unicodeiter_reduce with cost=-5 (threshold=375) 
unicodeiter_reduce
inline
                      
PyUnicode_FromUnicode inlined into unicodeiter_reduce 
unicodeiter_reduce
15363
        if (u == NULL)
15364
            return NULL;
15365
        return Py_BuildValue("N(N)", _PyObject_GetBuiltin("iter"), u);
inline
                                     
_PyObject_GetBuiltin will not be inlined into unicodeiter_reduce because its definition is unavailable 
unicodeiter_reduce
inline
               
_Py_BuildValue_SizeT will not be inlined into unicodeiter_reduce because its definition is unavailable 
unicodeiter_reduce
15366
    }
15367
}
15368
15369
PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
15370
15371
static PyObject *
15372
unicodeiter_setstate(unicodeiterobject *it, PyObject *state)
15373
{
15374
    Py_ssize_t index = PyLong_AsSsize_t(state);
inline
                       
PyLong_AsSsize_t will not be inlined into unicodeiter_setstate because its definition is unavailable 
unicodeiter_setstate
15375
    if (index == -1 && PyErr_Occurred())
inline
                       
PyErr_Occurred will not be inlined into unicodeiter_setstate because its definition is unavailable 
unicodeiter_setstate
15376
        return NULL;
15377
    if (it->it_seq != NULL) {
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
unicodeiter_setstate
gvn
            
load of type %struct._object* not eliminated because it is clobbered by call 
unicodeiter_setstate
15378
        if (index < 0)
15379
            index = 0;
15380
        else if (index > PyUnicode_GET_LENGTH(it->it_seq))
15381
            index = PyUnicode_GET_LENGTH(it->it_seq); /* iterator truncated */
15382
        it->it_index = index;
15383
    }
15384
    Py_RETURN_NONE;
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicodeiter_setstate
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicodeiter_setstate
15385
}
15386
15387
PyDoc_STRVAR(setstate_doc, "Set state information for unpickling.");
15388
15389
static PyMethodDef unicodeiter_methods[] = {
15390
    {"__length_hint__", (PyCFunction)unicodeiter_len, METH_NOARGS,
15391
     length_hint_doc},
15392
    {"__reduce__",      (PyCFunction)unicodeiter_reduce, METH_NOARGS,
15393
     reduce_doc},
15394
    {"__setstate__",    (PyCFunction)unicodeiter_setstate, METH_O,
15395
     setstate_doc},
15396
    {NULL,      NULL}       /* sentinel */
15397
};
15398
15399
PyTypeObject PyUnicodeIter_Type = {
15400
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
15401
    "str_iterator",         /* tp_name */
15402
    sizeof(unicodeiterobject),      /* tp_basicsize */
15403
    0,                  /* tp_itemsize */
15404
    /* methods */
15405
    (destructor)unicodeiter_dealloc,    /* tp_dealloc */
15406
    0,                  /* tp_print */
15407
    0,                  /* tp_getattr */
15408
    0,                  /* tp_setattr */
15409
    0,                  /* tp_reserved */
15410
    0,                  /* tp_repr */
15411
    0,                  /* tp_as_number */
15412
    0,                  /* tp_as_sequence */
15413
    0,                  /* tp_as_mapping */
15414
    0,                  /* tp_hash */
15415
    0,                  /* tp_call */
15416
    0,                  /* tp_str */
15417
    PyObject_GenericGetAttr,        /* tp_getattro */
15418
    0,                  /* tp_setattro */
15419
    0,                  /* tp_as_buffer */
15420
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
15421
    0,                  /* tp_doc */
15422
    (traverseproc)unicodeiter_traverse, /* tp_traverse */
15423
    0,                  /* tp_clear */
15424
    0,                  /* tp_richcompare */
15425
    0,                  /* tp_weaklistoffset */
15426
    PyObject_SelfIter,          /* tp_iter */
15427
    (iternextfunc)unicodeiter_next,     /* tp_iternext */
15428
    unicodeiter_methods,            /* tp_methods */
15429
    0,
15430
};
15431
15432
static PyObject *
15433
unicode_iter(PyObject *seq)
15434
{
15435
    unicodeiterobject *it;
15436
15437
    if (!PyUnicode_Check(seq)) {
15438
        PyErr_BadInternalCall();
inline
        
_PyErr_BadInternalCall will not be inlined into unicode_iter because its definition is unavailable 
unicode_iter
15439
        return NULL;
15440
    }
15441
    if (PyUnicode_READY(seq) == -1)
inline
        
_PyUnicode_Ready too costly to inline (cost=630, threshold=625) 
unicode_iter
inline
        
_PyUnicode_Ready will not be inlined into unicode_iter 
unicode_iter
15442
        return NULL;
15443
    it = PyObject_GC_New(unicodeiterobject, &PyUnicodeIter_Type);
inline
         
_PyObject_GC_New will not be inlined into unicode_iter because its definition is unavailable 
unicode_iter
15444
    if (it == NULL)
15445
        return NULL;
15446
    it->it_index = 0;
15447
    Py_INCREF(seq);
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_iter
15448
    it->it_seq = seq;
15449
    _PyObject_GC_TRACK(it);
inline
    
Py_FatalError will not be inlined into unicode_iter because its definition is unavailable 
unicode_iter
gvn
    
load of type i64 not eliminated because it is clobbered by call 
unicode_iter
gvn
    
load of type %struct.anon.1* not eliminated because it is clobbered by store 
unicode_iter
gvn
    
load of type %struct.anon.1* not eliminated in favor of load because it is clobbered by store 
unicode_iter
15450
    return (PyObject *)it;
15451
}
15452
15453
15454
size_t
15455
Py_UNICODE_strlen(const Py_UNICODE *u)
15456
{
15457
    int res = 0;
15458
    while(*u++)
loop-vectorize
    
loop not vectorized: could not determine number of loop iterations 
Py_UNICODE_strlen
loop-vectorize
    
loop not vectorized 
Py_UNICODE_strlen
loop-vectorize
    
loop not vectorized: could not determine number of loop iterations 
Py_UNICODE_strcat
loop-vectorize
    
loop not vectorized 
Py_UNICODE_strcat
loop-vectorize
    
loop not vectorized: could not determine number of loop iterations 
Py_UNICODE_strrchr
loop-vectorize
    
loop not vectorized 
Py_UNICODE_strrchr
15459
        res++;
15460
    return res;
15461
}
15462
15463
Py_UNICODE*
15464
Py_UNICODE_strcpy(Py_UNICODE *s1, const Py_UNICODE *s2)
15465
{
15466
    Py_UNICODE *u = s1;
15467
    while ((*u++ = *s2++));
gvn
                   
load of type i32 not eliminated because it is clobbered by store 
Py_UNICODE_strcpy
gvn
                   
load of type i32 not eliminated because it is clobbered by store 
Py_UNICODE_strcat
loop-vectorize
    
loop not vectorized: could not determine number of loop iterations 
Py_UNICODE_strcpy
loop-vectorize
    
loop not vectorized 
Py_UNICODE_strcpy
loop-vectorize
    
loop not vectorized: could not determine number of loop iterations 
Py_UNICODE_strcat
loop-vectorize
    
loop not vectorized 
Py_UNICODE_strcat
15468
    return s1;
15469
}
15470
15471
Py_UNICODE*
15472
Py_UNICODE_strncpy(Py_UNICODE *s1, const Py_UNICODE *s2, size_t n)
15473
{
15474
    Py_UNICODE *u = s1;
15475
    while ((*u++ = *s2++))
gvn
                   
load of type i32 not eliminated because it is clobbered by store 
Py_UNICODE_strncpy
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
Py_UNICODE_strncpy
loop-vectorize
    
loop not vectorized 
Py_UNICODE_strncpy
15476
        if (n-- == 0)
15477
            break;
15478
    return s1;
15479
}
15480
15481
Py_UNICODE*
15482
Py_UNICODE_strcat(Py_UNICODE *s1, const Py_UNICODE *s2)
15483
{
15484
    Py_UNICODE *u1 = s1;
15485
    u1 += Py_UNICODE_strlen(u1);
inline
          
Py_UNICODE_strlen can be inlined into Py_UNICODE_strcat with cost=5 (threshold=250) 
Py_UNICODE_strcat
inline
          
Py_UNICODE_strlen inlined into Py_UNICODE_strcat 
Py_UNICODE_strcat
15486
    Py_UNICODE_strcpy(u1, s2);
inline
    
Py_UNICODE_strcpy can be inlined into Py_UNICODE_strcat with cost=-20 (threshold=250) 
Py_UNICODE_strcat
inline
    
Py_UNICODE_strcpy inlined into Py_UNICODE_strcat 
Py_UNICODE_strcat
15487
    return s1;
15488
}
15489
15490
int
15491
Py_UNICODE_strcmp(const Py_UNICODE *s1, const Py_UNICODE *s2)
15492
{
15493
    while (*s1 && *s2 && *s1 == *s2)
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
Py_UNICODE_strcmp
loop-vectorize
    
loop not vectorized 
Py_UNICODE_strcmp
15494
        s1++, s2++;
15495
    if (*s1 && *s2)
15496
        return (*s1 < *s2) ? -1 : +1;
15497
    if (*s1)
gvn
        
load of type i32 eliminated in favor of phi 
Py_UNICODE_strcmp
15498
        return 1;
15499
    if (*s2)
15500
        return -1;
15501
    return 0;
15502
}
15503
15504
int
15505
Py_UNICODE_strncmp(const Py_UNICODE *s1, const Py_UNICODE *s2, size_t n)
15506
{
15507
    Py_UNICODE u1, u2;
15508
    for (; n != 0; n--) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
Py_UNICODE_strncmp
loop-vectorize
    
loop not vectorized 
Py_UNICODE_strncmp
15509
        u1 = *s1;
15510
        u2 = *s2;
15511
        if (u1 != u2)
15512
            return (u1 < u2) ? -1 : +1;
15513
        if (u1 == '\0')
15514
            return 0;
15515
        s1++;
15516
        s2++;
15517
    }
15518
    return 0;
15519
}
15520
15521
Py_UNICODE*
15522
Py_UNICODE_strchr(const Py_UNICODE *s, Py_UNICODE c)
15523
{
15524
    const Py_UNICODE *p;
15525
    for (p = s; *p; p++)
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
Py_UNICODE_strchr
loop-vectorize
    
loop not vectorized 
Py_UNICODE_strchr
15526
        if (*p == c)
15527
            return (Py_UNICODE*)p;
15528
    return NULL;
15529
}
15530
15531
Py_UNICODE*
15532
Py_UNICODE_strrchr(const Py_UNICODE *s, Py_UNICODE c)
15533
{
15534
    const Py_UNICODE *p;
15535
    p = s + Py_UNICODE_strlen(s);
inline
            
Py_UNICODE_strlen can be inlined into Py_UNICODE_strrchr with cost=5 (threshold=250) 
Py_UNICODE_strrchr
inline
            
Py_UNICODE_strlen inlined into Py_UNICODE_strrchr 
Py_UNICODE_strrchr
15536
    while (p != s) {
loop-vectorize
    
loop not vectorized: loop control flow is not understood by vectorizer 
Py_UNICODE_strrchr
loop-vectorize
    
loop not vectorized 
Py_UNICODE_strrchr
15537
        p--;
15538
        if (*p == c)
15539
            return (Py_UNICODE*)p;
15540
    }
15541
    return NULL;
15542
}
15543
15544
Py_UNICODE*
15545
PyUnicode_AsUnicodeCopy(PyObject *unicode)
15546
{
15547
    Py_UNICODE *u, *copy;
15548
    Py_ssize_t len, size;
15549
15550
    if (!PyUnicode_Check(unicode)) {
15551
        PyErr_BadArgument();
inline
        
PyErr_BadArgument will not be inlined into PyUnicode_AsUnicodeCopy because its definition is unavailable 
PyUnicode_AsUnicodeCopy
15552
        return NULL;
15553
    }
15554
    u = PyUnicode_AsUnicodeAndSize(unicode, &len);
inline
        
PyUnicode_AsUnicodeAndSize too costly to inline (cost=440, threshold=250) 
PyUnicode_AsUnicodeCopy
inline
        
PyUnicode_AsUnicodeAndSize will not be inlined into PyUnicode_AsUnicodeCopy 
PyUnicode_AsUnicodeCopy
15555
    if (u == NULL)
15556
        return NULL;
15557
    /* Ensure we won't overflow the size. */
15558
    if (len > ((PY_SSIZE_T_MAX / (Py_ssize_t)sizeof(Py_UNICODE)) - 1)) {
gvn
        
load of type i64 not eliminated because it is clobbered by call 
PyUnicode_AsUnicodeCopy
15559
        PyErr_NoMemory();
inline
        
PyErr_NoMemory will not be inlined into PyUnicode_AsUnicodeCopy because its definition is unavailable 
PyUnicode_AsUnicodeCopy
15560
        return NULL;
15561
    }
15562
    size = len + 1; /* copy the null character */
15563
    size *= sizeof(Py_UNICODE);
15564
    copy = PyMem_Malloc(size);
inline
           
PyMem_Malloc will not be inlined into PyUnicode_AsUnicodeCopy because its definition is unavailable 
PyUnicode_AsUnicodeCopy
15565
    if (copy == NULL) {
15566
        PyErr_NoMemory();
inline
        
PyErr_NoMemory will not be inlined into PyUnicode_AsUnicodeCopy because its definition is unavailable 
PyUnicode_AsUnicodeCopy
15567
        return NULL;
15568
    }
15569
    memcpy(copy, u, size);
15570
    return copy;
15571
}
15572
15573
/* A _string module, to export formatter_parser and formatter_field_name_split
15574
   to the string.Formatter class implemented in Python. */
15575
15576
static PyMethodDef _string_methods[] = {
15577
    {"formatter_field_name_split", (PyCFunction) formatter_field_name_split,
15578
     METH_O, PyDoc_STR("split the argument as a field name")},
15579
    {"formatter_parser", (PyCFunction) formatter_parser,
15580
     METH_O, PyDoc_STR("parse the argument as a format string")},
15581
    {NULL, NULL}
15582
};
15583
15584
static struct PyModuleDef _string_module = {
15585
    PyModuleDef_HEAD_INIT,
15586
    "_string",
15587
    PyDoc_STR("string helper module"),
15588
    0,
15589
    _string_methods,
15590
    NULL,
15591
    NULL,
15592
    NULL,
15593
    NULL
15594
};
15595
15596
PyMODINIT_FUNC
15597
PyInit__string(void)
15598
{
15599
    return PyModule_Create(&_string_module);
inline
           
PyModule_Create2 will not be inlined into PyInit__string because its definition is unavailable 
PyInit__string
15600
}
15601
15602
15603
#ifdef __cplusplus
15604
}
15605
#endif
15606
15607